diff --git a/.travis.yml b/.travis.yml index 87de895ddadfafb644a49ef6887b1321cf29ef53..ad1cc0ae14a4746574ccf78fc93ada2be46a0ecb 100644 --- a/.travis.yml +++ b/.travis.yml @@ -20,6 +20,7 @@ before_install: - | function timeout() { perl -e 'alarm shift; exec @ARGV' "$@"; } script: + - "travis_wait 30 sleep 1800 &" - | # 43min timeout paddle/scripts/paddle_docker_build.sh ${JOB} diff --git a/cmake/inference_lib.cmake b/cmake/inference_lib.cmake index 161bb29c818866175cd97a6d5937530a10324dbf..e2499fd464a1525e6d9ba34e99f262eec502de73 100644 --- a/cmake/inference_lib.cmake +++ b/cmake/inference_lib.cmake @@ -191,6 +191,13 @@ copy(fluid_lib_dist ${src_dir}/${module}/ir/*.h ${src_dir}/${module}/fleet/*.h DSTS ${dst_dir}/${module} ${dst_dir}/${module}/details ${dst_dir}/${module} ${dst_dir}/${module} ${dst_dir}/${module} ${dst_dir}/${module}/ir/memory_optimize_pass ${dst_dir}/${module}/ir ${dst_dir}/${module}/fleet) + +set(module "imperative") +copy(fluid_lib_dist + SRCS ${src_dir}/${module}/type_defs.h ${src_dir}/${module}/dygraph_grad_maker.h ${src_dir}/${module}/layer.h ${src_dir}/${module}/flags.h + DSTS ${dst_dir}/${module}/ ${dst_dir}/${module}/ ${dst_dir}/${module}/ ${dst_dir}/${module}/ + ) + set(module "operators") copy(fluid_lib_dist SRCS ${src_dir}/${module}/reader/blocking_queue.h diff --git a/paddle/fluid/framework/details/op_registry.h b/paddle/fluid/framework/details/op_registry.h index 0f03ca51da778d4ce8aefa493d2227e789614679..4d6ad8762401bd0669dd22efdcb108e52f56d605 100644 --- a/paddle/fluid/framework/details/op_registry.h +++ b/paddle/fluid/framework/details/op_registry.h @@ -27,6 +27,8 @@ limitations under the License. */ #include "paddle/fluid/framework/op_proto_maker.h" #include "paddle/fluid/framework/operator.h" #include "paddle/fluid/framework/var_type_inference.h" +#include "paddle/fluid/imperative/dygraph_grad_maker.h" +#include "paddle/fluid/imperative/type_defs.h" namespace paddle { namespace framework { @@ -40,6 +42,7 @@ enum OpInfoFillType { kShapeInference = 4, kInplaceOpInference = 5, kNoNeedBufferVarsInference = 6, + kGradOpBaseMaker = 7, kUnknown = -1 }; @@ -54,6 +57,7 @@ using OpRegistryClasses = std::tuple< // NOLINT TypePair, // NOLINT TypePair, // NOLINT TypePair, // NOLINT + TypePair, // NOLINT TypePair, // NOLINT TypePair, // NOLINT TypePair, // NOLINT @@ -186,8 +190,21 @@ struct OpInfoFiller { }; info->use_default_grad_op_desc_maker_ = - std::is_base_of, T>::value || - std::is_base_of, T>::value; + std::is_base_of, T>::value || + std::is_base_of, T>::value; + } +}; + +template +struct OpInfoFiller { + void operator()(const char* op_type, OpInfo* info) const { + info->dygraph_grad_op_maker_ = []( + const imperative::OpBase* fw_op_base, + const imperative::NameVarBaseMap& var_base_map_in, + const imperative::NameVarBaseMap& var_base_map_out) { + T maker(fw_op_base, var_base_map_in, var_base_map_out); + return maker(); + }; } }; diff --git a/paddle/fluid/framework/grad_op_desc_maker.h b/paddle/fluid/framework/grad_op_desc_maker.h index 25a64b69ae8b459d6daefb502e9fba84b5bcf3ba..5fda027453cca589363b3b3ce8d90497227d6332 100644 --- a/paddle/fluid/framework/grad_op_desc_maker.h +++ b/paddle/fluid/framework/grad_op_desc_maker.h @@ -21,6 +21,9 @@ limitations under the License. */ #include #include "paddle/fluid/framework/op_desc.h" #include "paddle/fluid/framework/operator.h" +#include "paddle/fluid/imperative/dygraph_grad_maker.h" +#include "paddle/fluid/imperative/layer.h" +#include "paddle/fluid/imperative/type_defs.h" namespace paddle { namespace framework { @@ -97,6 +100,8 @@ class GradOpDescMakerBase { return ret_val; } + std::vector Empty() const { return {}; } + std::vector InputNames() const { return this->fwd_op_.InputNames(); } @@ -132,7 +137,9 @@ class GradOpDescMakerBase { std::string ForwardOpType() const { return this->fwd_op_.Type(); } protected: - const OpDesc& ForwardOp() const { return fwd_op_; } + bool HasInput(const std::string& name) const { + return (fwd_op_.Inputs().count(name) > 0); + } private: const OpDesc& fwd_op_; @@ -143,11 +150,24 @@ class GradOpDescMakerBase { std::vector grad_block_; }; -class SingleGradOpDescMaker : public GradOpDescMakerBase { +template +class SingleGradOpMaker { + public: + std::vector> operator()() const { + PADDLE_ENFORCE(false, "should not call this function"); + return {}; + } + + protected: + virtual std::unique_ptr Apply() const = 0; +}; + +template <> +class SingleGradOpMaker : public GradOpDescMakerBase { public: using GradOpDescMakerBase::GradOpDescMakerBase; - std::vector> operator()() const final { + std::vector> operator()() const { std::vector> retv; retv.emplace_back(this->Apply()); return retv; @@ -157,14 +177,32 @@ class SingleGradOpDescMaker : public GradOpDescMakerBase { virtual std::unique_ptr Apply() const = 0; }; -template -class DefaultGradOpDescMaker final : public SingleGradOpDescMaker { +template <> +class SingleGradOpMaker + : public imperative::GradOpBaseMakerBase { + public: + using GradOpBaseMakerBase::GradOpBaseMakerBase; + public: - using SingleGradOpDescMaker::SingleGradOpDescMaker; + std::vector> operator()() const { + std::vector> retv; + retv.emplace_back(this->Apply()); + + return retv; + } protected: - std::unique_ptr Apply() const final { - auto* grad = new OpDesc(); + virtual std::unique_ptr Apply() const = 0; +}; + +template +class DefaultGradOpMaker final : public SingleGradOpMaker { + public: + using SingleGradOpMaker::SingleGradOpMaker; + + protected: + std::unique_ptr Apply() const final { + auto* grad = new T(); grad->SetType(this->ForwardOpType() + "_grad"); for (auto& input_param : this->InputNames()) { @@ -180,15 +218,35 @@ class DefaultGradOpDescMaker final : public SingleGradOpDescMaker { grad->SetAttrMap(this->Attrs()); - return std::unique_ptr(grad); + return std::unique_ptr(grad); } }; -class EmptyGradOpMaker final : public GradOpDescMakerBase { +template +class EmptyGradOpMaker { + public: + virtual std::vector> operator()() + const final { /* NOLINT */ + return {}; + } +}; + +template <> +class EmptyGradOpMaker final : public GradOpDescMakerBase { public: using GradOpDescMakerBase::GradOpDescMakerBase; std::vector> operator()() const final { return {}; } }; +template <> +class EmptyGradOpMaker final + : public imperative::GradOpBaseMakerBase { + public: + using GradOpBaseMakerBase::GradOpBaseMakerBase; + std::vector> operator()() const final { + return {}; + } +}; + } // namespace framework } // namespace paddle diff --git a/paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass_tester.cc b/paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass_tester.cc index 427d7bc9aeb15f4adb4a486c511630836bf2bb73..6ebe642a7d39c2714736781dde266f4bb0025703 100644 --- a/paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass_tester.cc +++ b/paddle/fluid/framework/ir/mkldnn/conv_bias_mkldnn_fuse_pass_tester.cc @@ -18,6 +18,7 @@ #include "paddle/fluid/platform/place.h" #include "paddle/fluid/framework/op_proto_maker.h" +#include "paddle/fluid/imperative/type_defs.h" namespace paddle { namespace framework { diff --git a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass_tester.cc b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass_tester.cc index 0a68944186773f84f734d81cf29dc5214d16e173..947f4fd37a9f843a455fc9dc8d0d9da318f0f1d2 100644 --- a/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass_tester.cc +++ b/paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass_tester.cc @@ -15,6 +15,7 @@ #include "paddle/fluid/framework/ir/mkldnn/cpu_quantize_pass.h" #include #include "paddle/fluid/framework/naive_executor.h" +#include "paddle/fluid/imperative/type_defs.h" #include "paddle/fluid/platform/place.h" namespace paddle { @@ -29,6 +30,7 @@ void SetOp(ProgramDesc* prog, const std::string& type, const std::string& name, op->SetType(type); op->SetAttr("use_mkldnn", use_mkldnn); op->SetAttr("name", name); + if (type == "conv2d") { op->SetInput("Input", {inputs[0]}); op->SetInput("Filter", {inputs[1]}); diff --git a/paddle/fluid/framework/op_desc.h b/paddle/fluid/framework/op_desc.h index 2f6fb9e298440e0aaac79d0dc5ad1e7d1aed6990..ebdb538696283e72f6e2b978dcc07ec7f1005f19 100644 --- a/paddle/fluid/framework/op_desc.h +++ b/paddle/fluid/framework/op_desc.h @@ -16,6 +16,7 @@ limitations under the License. */ #include #include +#include #include #include "paddle/fluid/framework/attribute.h" #include "paddle/fluid/framework/type_defs.h" diff --git a/paddle/fluid/framework/op_info.h b/paddle/fluid/framework/op_info.h index 1297d8de81fe1683333713b17100ab26a27fa985..79a6a06abb325e0f5149831fa0a68ffbe367f66a 100644 --- a/paddle/fluid/framework/op_info.h +++ b/paddle/fluid/framework/op_info.h @@ -42,6 +42,7 @@ struct OpInfo { InferShapeFN infer_shape_; InferInplaceOpFN infer_inplace_; InferNoNeedBufferVarsFN infer_no_need_buffer_vars_; + DygraphGradOpMakerFN dygraph_grad_op_maker_; // NOTE(zjl): this flag is added to check whether // the grad maker is the default one. @@ -81,6 +82,24 @@ struct OpInfo { // some op has no grad_op_maker, add check before use GradOpMaker() bool HasGradOpMaker() const { return grad_op_maker_ != nullptr; } + const DygraphGradOpMakerFN& DygraphGradOpMaker() const { + // Normally, proto_ should not be null, except some special operators, such + // as LeaklyReluDoubleGrad op. + std::string type = proto_ ? proto_->type() : "unknown"; + PADDLE_ENFORCE_NOT_NULL( + dygraph_grad_op_maker_, + "Operator %s's DygraphGradOpMaker has not been " + "registered.\nPlease check whether %s_op has " + "grad_op.\nIf not, please set stop_gradient to True " + "for its input and output variables using var.stop_gradient=True.", + type.c_str(), type.c_str()); + return dygraph_grad_op_maker_; + } + + bool HasDygraphGradOpMaker() const { + return dygraph_grad_op_maker_ != nullptr ? true : false; + } + bool HasInferInplace() const { return infer_inplace_ != nullptr; } const OpAttrChecker* Checker() const { return checker_; } diff --git a/paddle/fluid/framework/op_registry.h b/paddle/fluid/framework/op_registry.h index 3f14f47f0dddc0f203d03fcdcdb3213291ab6bdb..221ab352ad3ce3043c3c9219b33e7ca7ade1b23f 100644 --- a/paddle/fluid/framework/op_registry.h +++ b/paddle/fluid/framework/op_registry.h @@ -209,7 +209,8 @@ struct OpKernelRegistrarFunctorEx, \ + paddle::framework::EmptyGradOpMaker) /** * Macro to register OperatorKernel. diff --git a/paddle/fluid/framework/operator.cc b/paddle/fluid/framework/operator.cc index 6bcff6b059a07d9d937b317b5c43bef5d2a8fef3..c2851f9fd37d450778582f9c60a0cd08103fb5a3 100644 --- a/paddle/fluid/framework/operator.cc +++ b/paddle/fluid/framework/operator.cc @@ -1171,7 +1171,7 @@ proto::VarType::Type OperatorWithKernel::IndicateDataType( proto::VarType::Type dafault_data_type = static_cast(-1); proto::VarType::Type data_type = dafault_data_type; - for (auto& input : this->inputs_) { + for (auto& input : ctx.Context().inputs) { ParseInputDataType(ctx, input.first, &data_type); } PADDLE_ENFORCE_NE(data_type, dafault_data_type, diff --git a/paddle/fluid/framework/operator.h b/paddle/fluid/framework/operator.h index ab956a9474cd7c3b65e2304867fe11bf28787510..6a9af6af31588ead7ce47f2917d04dceba435d6c 100644 --- a/paddle/fluid/framework/operator.h +++ b/paddle/fluid/framework/operator.h @@ -385,6 +385,8 @@ class ExecutionContext { return *boost::get>((*kernel_configs_)[idx]); } + const RuntimeContext& Context() const { return ctx_; } + private: const OperatorBase& op_; const Scope& scope_; diff --git a/paddle/fluid/framework/type_defs.h b/paddle/fluid/framework/type_defs.h index 7f1bfb5d9a81d45ab7840ab18e62374cc6554f12..2397bfde3d1a23677146990bb61c24546c4140f5 100644 --- a/paddle/fluid/framework/type_defs.h +++ b/paddle/fluid/framework/type_defs.h @@ -20,6 +20,7 @@ limitations under the License. */ #include #include #include +#include "paddle/fluid/imperative/type_defs.h" #include "paddle/fluid/platform/variant.h" namespace paddle { @@ -54,6 +55,12 @@ using GradOpMakerFN = std::function>( std::unordered_map* /*grad_to_var*/, const std::vector& grad_block)>; +using DygraphGradOpMakerFN = + std::function>( + const imperative::OpBase* fw_op_base, + const imperative::NameVarBaseMap& var_base_map_in, + const imperative::NameVarBaseMap& var_base_map_out)>; + using InferVarTypeFN = std::function; diff --git a/paddle/fluid/imperative/dygraph_grad_maker.h b/paddle/fluid/imperative/dygraph_grad_maker.h new file mode 100644 index 0000000000000000000000000000000000000000..c2107f0a89f83318e5a623fcd23ef1262d81f13a --- /dev/null +++ b/paddle/fluid/imperative/dygraph_grad_maker.h @@ -0,0 +1,153 @@ +// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. +// +// 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 + +#include +#include +#include +#include + +#include "paddle/fluid/imperative/layer.h" +#include "paddle/fluid/imperative/type_defs.h" +#include "paddle/fluid/platform/enforce.h" +#include "paddle/fluid/platform/macros.h" + +namespace paddle { +namespace imperative { + +class GradOpBaseMakerBase { + public: + explicit GradOpBaseMakerBase(const OpBase* fw_op_base, + const NameVarBaseMap& var_base_map_in, + const NameVarBaseMap& var_base_map_out) + : fw_op_base_(fw_op_base), + var_base_map_in_(var_base_map_in), + var_base_map_out_(var_base_map_out) {} + + virtual ~GradOpBaseMakerBase() = default; + virtual std::vector> operator()() const = 0; + + std::vector> InputGrad( + const std::string& name, bool drop_empty_grad = true) const { + return GetVarBaseList(name, true, true); + } + + std::vector> OutputGrad( + const std::string& name) const { + return GetVarBaseList(name, true, false); + } + + std::vector> Input(const std::string name) const { + return GetVarBaseList(name, false, true); + } + + std::vector> Output(const std::string& name) const { + return GetVarBaseList(name, false, false); + } + + std::vector> Empty() const { return {}; } + + std::vector InputNames() const { + std::vector vec_temp; + vec_temp.reserve(var_base_map_in_.size()); + for (auto& it : var_base_map_in_) { + vec_temp.emplace_back(it.first); + } + + return vec_temp; + } + + std::vector OutputNames() const { + std::vector vec_temp; + vec_temp.reserve(var_base_map_out_.size()); + for (auto& it : var_base_map_out_) { + vec_temp.emplace_back(it.first); + } + + return vec_temp; + } + + const std::unordered_map& Attrs() const { + return fw_op_base_->Attrs(); + } + + const framework::Attribute& GetAttr(const std::string& name) const { + auto& map = fw_op_base_->Attrs(); + auto it = map.find(name); + PADDLE_ENFORCE(it != map.end(), + "Cannot find attribute [%s] in operator [%s]", name, + fw_op_base_->Type()); + + return it->second; + } + + template + inline const T& Attr(const std::string& name) const { + return boost::get(GetAttr(name)); + } + + std::string ForwardOpType() const { return fw_op_base_->Type(); } + + protected: + bool HasInput(const std::string& name) const { + auto it = var_base_map_in_.find(name); + + return it != var_base_map_in_.end(); + } + + private: + std::vector> GetVarBaseList(const std::string& name, + bool is_grad, + bool is_input) const { + const NameVarBaseMap& data_map = + is_input ? var_base_map_in_ : var_base_map_out_; + auto iterator = data_map.find(name); + + std::vector> vec_temp; + if (iterator != data_map.end()) { + vec_temp.reserve(iterator->second.size()); + + for (auto& var_base_temp : iterator->second) { + if (is_grad) { + PADDLE_ENFORCE_NOT_NULL(var_base_temp->GradVarBase(), + "VarBase grad of OP [%s] should not be null", + fw_op_base_->Type()); + auto grad_var_base_tmp = var_base_temp->GradVarBase(); + auto* tensor = grad_var_base_tmp->MutableVar() + ->GetMutable(); + tensor->Resize( + var_base_temp->Var().Get().dims()); + + vec_temp.emplace_back(grad_var_base_tmp); + } else { + vec_temp.emplace_back(var_base_temp); + } + } + } + + return vec_temp; + } + + private: + const OpBase* fw_op_base_; + const NameVarBaseMap& var_base_map_in_; + const NameVarBaseMap& var_base_map_out_; + + protected: + std::vector grad_block_; +}; + +} // namespace imperative +} // namespace paddle diff --git a/paddle/fluid/imperative/engine.cc b/paddle/fluid/imperative/engine.cc index 877e6ceb6a4cfa5305c88c44066d1deacf69ac88..0d9edce4db879cbfa0d674f964f233145501f518 100644 --- a/paddle/fluid/imperative/engine.cc +++ b/paddle/fluid/imperative/engine.cc @@ -173,6 +173,7 @@ void BasicEngine::PrepareDeps() { void BasicEngine::SumGradient(OpBase* op, std::shared_ptr src, VarBase* dst) { auto iter = accumulators_.find(dst); + PADDLE_ENFORCE_EQ(iter != accumulators_.end(), true, "Cannot find gradient of variable %s", dst->Name()); iter->second->Add(std::move(src), op->id()); @@ -195,16 +196,16 @@ void BasicEngine::Execute() { NameVarBaseMap tmp_outs; // A var may be coresponding to several grad var in one op std::unordered_map>> var_map; - size_t counter = 0; for (auto& bwd_out : bwd_outs) { auto& tmp_var_list = tmp_outs[bwd_out.first]; tmp_var_list.reserve(bwd_out.second.size()); for (auto& var : bwd_out.second) { - auto tmp_var = std::make_shared( - false, "Gtmp@" + std::to_string(counter++)); // Do not need grad + auto tmp_var = + std::make_shared(false, "Gtmp@"); // Do not need grad tmp_var_list.emplace_back(tmp_var); if (var) { var_map[var.get()].emplace_back(std::move(tmp_var)); + var->ClearGradOps(); } } @@ -227,6 +228,7 @@ void BasicEngine::Execute() { } // Step 3: Collect ready ops + for (auto* grad_pending_op : cur_op->GradPendingOps()) { PADDLE_ENFORCE_NOT_NULL(grad_pending_op); auto iter = op_deps_.find(grad_pending_op); diff --git a/paddle/fluid/imperative/layer.cc b/paddle/fluid/imperative/layer.cc index 8a5db26d7d7f158c3f436e3ad339dd29b8132735..573f75e1de8cc45efdc7a0f701c0e603647144fe 100644 --- a/paddle/fluid/imperative/layer.cc +++ b/paddle/fluid/imperative/layer.cc @@ -53,7 +53,18 @@ static framework::VariableNameMap CreateVarNameMap( const framework::OpInfo& op_info, const std::string& op_type, const NameVarBaseMap& varbase_map, bool is_input) { if (op_info.proto_ == nullptr) { - return {}; + framework::VariableNameMap result; + + for (auto& it : varbase_map) { + auto& var_vector = it.second; + std::vector args; + args.reserve(var_vector.size()); + for (auto& var_base : var_vector) { + args.emplace_back(var_base->Name()); + } + result[it.first] = std::move(args); + } + return result; } framework::VariableNameMap result; @@ -220,21 +231,20 @@ std::shared_ptr VarBase::NewVarBase(const platform::Place& dst_place, } // create OpBase from optype OpBase::OpBase(size_t id, const std::string& type, const NameVarBaseMap& ins, - const NameVarBaseMap& outs, framework::AttributeMap attrs, + const NameVarBaseMap& outs, const framework::AttributeMap& attrs, const platform::Place& place) - : id_(id), place_(place) { + : id_(id), place_(place), attrs_(attrs) { const auto& info = framework::OpInfoMap::Instance().Get(type); // Step 1: Run forward if (info.Checker() != nullptr) { - info.Checker()->Check(&attrs); + 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), - std::move(attrs)); + std::move(output_name_map), attrs); VLOG(3) << "Construct Op: " << type << std::endl; } @@ -245,6 +255,18 @@ OpBase::OpBase(size_t id, const framework::OpDesc& op_desc, VLOG(3) << "Construct Op: " << op_desc.Type() << std::endl; } +void OpBase::CreateOperatorBase() { + const auto& info = framework::OpInfoMap::Instance().Get(type_); + 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_); +} + void OpBase::Run(const NameVarBaseMap& ins, const NameVarBaseMap& outs) { auto* op_kernel = dynamic_cast(op_.get()); PADDLE_ENFORCE_NOT_NULL(op_kernel, "only support op with kernel"); diff --git a/paddle/fluid/imperative/layer.h b/paddle/fluid/imperative/layer.h index 4ef22c97d0d4c940dac24215906eec14d398994b..a0fa11a7250a6e3db98ee97135c252041c0a4116 100644 --- a/paddle/fluid/imperative/layer.h +++ b/paddle/fluid/imperative/layer.h @@ -182,6 +182,7 @@ class VarBase { framework::Variable var_; std::string name_; std::shared_ptr grad_var_; + mutable size_t copied_counter_ = 0; // grad_op indicates which grad_op will this var be used as input @@ -271,6 +272,7 @@ class RuntimeInferVarTypeContext : public framework::InferVarTypeContext { const std::vector& Output( const std::string& name) const override { auto iter = output_names_.find(name); + PADDLE_ENFORCE_EQ(iter != output_names_.end(), true, "Cannot find output %s", name); return iter->second; @@ -279,6 +281,7 @@ class RuntimeInferVarTypeContext : public framework::InferVarTypeContext { framework::proto::VarType::Type GetType( const std::string& name) const override { auto iter = var_set_.find(name); + PADDLE_ENFORCE_EQ(iter != var_set_.end(), true, "Cannot find var %s in GetType", name); return iter->second->Type(); @@ -296,6 +299,7 @@ class RuntimeInferVarTypeContext : public framework::InferVarTypeContext { framework::proto::VarType::Type GetDataType( const std::string& name) const override { auto iter = var_set_.find(name); + PADDLE_ENFORCE_EQ(iter != var_set_.end(), true, "Cannot find var %s in GetDataType", name); return iter->second->DataType(); @@ -380,6 +384,10 @@ class OpBase : public std::enable_shared_from_this { return grad_pending_ops_; } + void SetGradPendingOps(std::vector vec_temp) { + grad_pending_ops_.swap(vec_temp); + } + void InsertGradPendingOps(OpBase* op) { grad_pending_ops_.emplace_back(op); } void SortGradPendingOps() { @@ -406,12 +414,56 @@ class OpBase : public std::enable_shared_from_this { private: OpBase(size_t id, const std::string& type, const NameVarBaseMap& ins, - const NameVarBaseMap& outs, framework::AttributeMap attrs, + const NameVarBaseMap& outs, const framework::AttributeMap& attrs, const platform::Place& place); OpBase(size_t id, const framework::OpDesc& op_desc, const platform::Place& place); + public: + OpBase() {} + + void SetType(const std::string& type) { type_ = type; } + void SetInput(const std::string& name, + std::vector> vec_var_base) { + ins_[name] = std::move(vec_var_base); + } + void SetOutput(const std::string& name, + std::vector> vec_var_base) { + outs_[name] = std::move(vec_var_base); + } + void SetAttrMap(const framework::AttributeMap& attrs) { attrs_ = attrs; } + void SetAttr(const std::string& name, const framework::Attribute& v) { + attrs_[name] = v; + } + void SetBlockAttr(const std::string& name, framework::BlockDesc* block) { + PADDLE_THROW("SetBlockAttr is not support in dygraph OpBase"); + } + + const framework::AttributeMap& Attrs() { return attrs_; } + + void CreateOperatorBase(); + + void SetId(size_t id) { id_ = id; } + void SetPlace(platform::Place place) { place_ = place; } + + bool HasAttr(const std::string& name) const { + return attrs_.find(name) != attrs_.end(); + } + + const framework::Attribute& GetAttr(const std::string& name) const { + auto it = attrs_.find(name); + PADDLE_ENFORCE(it != attrs_.end(), "can not find attribute [%s]", name); + + return it->second; + } + + template + inline const T& Attr(const std::string& name) const { + return boost::get(GetAttr(name)); + } + + private: size_t id_; std::unique_ptr op_; @@ -421,11 +473,14 @@ class OpBase : public std::enable_shared_from_this { // Not need to be std::weak_ptr, because op is binded to a certain Tracer, // and would not be used by a Tracer that does not create itself. + std::vector grad_pending_ops_; // This part is only used for backward NameVarBaseMap ins_; NameVarBaseMap outs_; + std::string type_; + framework::AttributeMap attrs_; }; } // namespace imperative diff --git a/paddle/fluid/imperative/prepared_operator.cc b/paddle/fluid/imperative/prepared_operator.cc index 6f8ee92bdfc7ba9c68f8e567f3f1bad0a2cbabeb..b3ec5af445cc70979fbb3771a7df7a6b074c0ecb 100644 --- a/paddle/fluid/imperative/prepared_operator.cc +++ b/paddle/fluid/imperative/prepared_operator.cc @@ -37,6 +37,7 @@ void PreparedOp::PrepareData( const auto* tensor = GetTensorFromVar(var_base->Var()); if (tensor && tensor->IsInitialized()) { auto tmp_place = tensor->place(); + // TODO(jiabin): Support transform data layout when we Verify it on more // tests if (!(tmp_place == place)) { diff --git a/paddle/fluid/imperative/tests/CMakeLists.txt b/paddle/fluid/imperative/tests/CMakeLists.txt index f32f0a1726fc07bab5fdbb971fa258a97e3c8f7f..2b2d91485fd440d4d157993edb7d45864bc355e5 100644 --- a/paddle/fluid/imperative/tests/CMakeLists.txt +++ b/paddle/fluid/imperative/tests/CMakeLists.txt @@ -2,4 +2,4 @@ cc_test(nccl_context_test SRCS nccl_context_test.cc DEPS nccl_context) cc_test(test_gradient_accmulator SRCS test_gradient_accmulator.cc DEPS gradient_accumulator memcpy) cc_test(test_layer SRCS test_layer.cc DEPS layer proto_desc operator op_registry variable_helper mul_op memcpy) cc_test(test_prepare_op SRCS test_prepare_op.cc DEPS prepared_operator op_info split_op layer concat_and_split assign_op place) -cc_test(test_tracer SRCS test_tracer.cc DEPS tracer layer proto_desc operator op_registry variable_helper mul_op memcpy) +cc_test(test_tracer SRCS test_tracer.cc DEPS tracer layer proto_desc operator op_registry variable_helper mul_op reduce_sum_op elementwise_add_op memcpy) diff --git a/paddle/fluid/imperative/tests/test_tracer.cc b/paddle/fluid/imperative/tests/test_tracer.cc index 9ef13a5d45b2e8894f77c698c036a6820d377c12..4e97f97853e07438c833f1debdc3c84e01d62577 100644 --- a/paddle/fluid/imperative/tests/test_tracer.cc +++ b/paddle/fluid/imperative/tests/test_tracer.cc @@ -74,6 +74,45 @@ TEST(test_tracer, test_trace_op) { } } +TEST(test_tracer, test_trace_op_with_backward) { + // Doing an mul + imperative::Tracer tracer; + std::shared_ptr x_in( + new imperative::VarBase(true, "x_in")); + std::shared_ptr y_in( + new imperative::VarBase(true, "y_in")); + std::shared_ptr vout( + new imperative::VarBase(true, "vout")); + platform::CPUPlace place; + std::vector src_data(10, 2.0); + std::vector dims1 = {2, 5}; + std::vector dims2 = {5, 2}; + + auto* x_in_tensor = x_in->MutableVar()->GetMutable(); + auto* y_in_tensor = y_in->MutableVar()->GetMutable(); + x_in_tensor->Resize(framework::make_ddim(dims1)); + auto* mutable_x = x_in_tensor->mutable_data(place); + paddle::memory::Copy(place, mutable_x, place, src_data.data(), + sizeof(float) * src_data.size()); + y_in_tensor->Resize(framework::make_ddim(dims2)); + auto* mutable_y = y_in_tensor->mutable_data(place); + paddle::memory::Copy(place, mutable_y, place, src_data.data(), + sizeof(float) * src_data.size()); + + var_pair x_pair = var_pair("X", vb_vector(1, x_in)); + var_pair y_pair = var_pair("Y", vb_vector(1, y_in)); + 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 mul_attr_map; + mul_attr_map["use_mkldnn"] = false; + tracer.TraceOp("mul", ins, outs, mul_attr_map, place, true); + const auto& out_tensor = vout->Var().Get(); + for (size_t i = 0; i < vout->Var().Get().numel(); i++) { + ASSERT_EQ(out_tensor.data()[i], 20.0); + } +} + TEST(test_tracer, test_track_backward_output) { // Doing an mul imperative::Tracer tracer; @@ -151,15 +190,17 @@ TEST(test_tracer, test_trace_op_with_multi_device_inputs) { imperative::Tracer tracer; std::shared_ptr x_in( new imperative::VarBase(true, "x_in")); + x_in->SetOverridedStopGradient(false); // force to run backward std::shared_ptr y_in( new imperative::VarBase(true, "y_in")); + y_in->SetOverridedStopGradient(false); std::shared_ptr vout( new imperative::VarBase(true, "vout")); platform::CPUPlace place; platform::CUDAPlace gpu_place(0); std::vector src_data(10, 2.0); std::vector dims1 = {2, 5}; - std::vector dims2 = {5, 2}; + std::vector dims2 = {2, 5}; auto* x_in_tensor = x_in->MutableVar()->GetMutable(); auto* y_in_tensor = y_in->MutableVar()->GetMutable(); @@ -178,14 +219,54 @@ TEST(test_tracer, test_trace_op_with_multi_device_inputs) { imperative::NameVarBaseMap outs = {out_pair}; framework::AttributeMap mul_attr_map; mul_attr_map["use_mkldnn"] = false; - tracer.TraceOp("mul", ins, outs, mul_attr_map, gpu_place, true); + tracer.TraceOp("elementwise_add", ins, outs, mul_attr_map, gpu_place, true); + + // run reduce sum + std::shared_ptr reduce_sum_out( + new imperative::VarBase(true, "reduce_sum_out")); + var_pair reduce_sum_in_pair = var_pair("X", vb_vector(1, vout)); + var_pair reduce_sum_out_pair = var_pair("Out", vb_vector(1, reduce_sum_out)); + imperative::NameVarBaseMap reduce_in = {reduce_sum_in_pair}; + imperative::NameVarBaseMap reduce_out = {reduce_sum_out_pair}; + framework::AttributeMap reduce_attr_map; + tracer.TraceOp("reduce_sum", reduce_in, reduce_out, reduce_attr_map, + gpu_place, true); + detail::BackwardStrategy back_st; + imperative::Engine* engine = tracer.GetDefaultEngine(); + engine->Init(reduce_sum_out.get(), back_st); + engine->Execute(); + framework::LoDTensor rlt; framework::TensorCopySync(vout->Var().Get(), place, &rlt); for (size_t i = 0; i < rlt.numel(); i++) { - ASSERT_EQ(rlt.data()[i], 20.0); + ASSERT_EQ(rlt.data()[i], 4.0); + } + + framework::LoDTensor out_grad; + framework::TensorCopySync(vout->GradVar().Get(), place, + &out_grad); + for (size_t i = 0; i < out_grad.numel(); ++i) { + ASSERT_EQ(out_grad.data()[i], 1.0); + } + + framework::LoDTensor x_grad; + framework::TensorCopySync(x_in->GradVar().Get(), place, + &x_grad); + + for (size_t i = 0; i < x_grad.numel(); ++i) { + ASSERT_EQ(x_grad.data()[i], 1.0); + } + + framework::LoDTensor y_grad; + framework::TensorCopySync(y_in->GradVar().Get(), place, + &y_grad); + + for (size_t i = 0; i < y_grad.numel(); ++i) { + ASSERT_EQ(y_grad.data()[i], 1.0); } } + #endif TEST(test_tracer, test_unique_name_generator) { @@ -201,3 +282,6 @@ TEST(test_tracer, test_unique_name_generator) { } // namespace paddle USE_OP(mul); +USE_OP(reduce_sum); +USE_OP(reduce_sum_grad); +USE_OP(elementwise_add); diff --git a/paddle/fluid/imperative/tracer.cc b/paddle/fluid/imperative/tracer.cc index ce107daa1586829af091136af35f9da151fc1514..7b160cd22b3cb707126f16679b000142fd80865c 100644 --- a/paddle/fluid/imperative/tracer.cc +++ b/paddle/fluid/imperative/tracer.cc @@ -12,6 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. #include "paddle/fluid/imperative/tracer.h" +#include #include #include #include "paddle/fluid/platform/profiler.h" @@ -19,14 +20,17 @@ namespace paddle { namespace imperative { -static std::vector> CreateGradOpDescs( - const framework::OpInfo& op_info, const framework::OpDesc& op_desc, - const std::unordered_set& no_grad_set, - const std::vector& grad_sub_block, - std::unordered_map* grad_to_var) { - if (op_info.grad_op_maker_) { - return op_info.grad_op_maker_(op_desc, no_grad_set, grad_to_var, - grad_sub_block); +struct OpBaseCmp { + bool operator()(OpBase* first, OpBase* second) { + return first->id() > second->id(); + } +}; + +static std::vector> CreateGradOpBases( + const OpBase* fw_op_base, const NameVarBaseMap& in, + const NameVarBaseMap& out) { + if (fw_op_base->Info().dygraph_grad_op_maker_) { + return fw_op_base->Info().dygraph_grad_op_maker_(fw_op_base, in, out); } else { return {}; } @@ -57,9 +61,7 @@ void Tracer::TraceOp(const std::string& type, const NameVarBaseMap& ins, } if (ComputeRequiredGrad(ins, outs, trace_backward)) { - TraceBackward(op, framework::OpDesc(op->Type(), op->InputNameMap(), - op->OutputNameMap(), op->Attrs()), - ins, outs); + TraceBackward(op, ins, outs); } else { VLOG(3) << "No Grad to track for Op: " << type; } @@ -84,7 +86,6 @@ bool Tracer::ComputeRequiredGrad(const NameVarBaseMap& ins, } void Tracer::TraceBackward(const std::shared_ptr& fwd_op, - const framework::OpDesc& fwd_op_desc, const NameVarBaseMap& ins, const NameVarBaseMap& outs) { // grad_to_var is a map of framework::GradVarName(in_var_name/out_var_name) -> @@ -92,168 +93,70 @@ void Tracer::TraceBackward(const std::shared_ptr& fwd_op, std::unordered_map grad_to_var; // Get grad_op_desc using fwd_op_desc - std::vector> grad_op_descs_ = - CreateGradOpDescs(fwd_op->Info(), fwd_op_desc, {}, {}, &grad_to_var); - - // Create grad_ops using grad_op_descs + std::vector> grad_op_bases_ = + CreateGradOpBases(fwd_op.get(), ins, outs); - size_t grad_op_num = grad_op_descs_.size(); + size_t grad_op_num = grad_op_bases_.size(); - VLOG(3) << "Create " << grad_op_num << " grad op desc(s) to op " - << fwd_op->Type(); - - if (grad_op_num == 0) { - return; - } - // Build a map to record var_name -> std::shared_ptr*, - // so that we can find suitable var in grad op descs - std::unordered_map*> name_to_var; - for (auto& pair : ins) { - for (auto& var : pair.second) { - auto& var_ptr = name_to_var[var->Name()]; - PADDLE_ENFORCE_EQ(var_ptr == nullptr || var_ptr->get() == var.get(), true, - "There are different variables with same name %s", - var->Name()); - var_ptr = &var; + std::set set_input_vars; + for (auto& fwd_in_it : ins) { + for (auto& var_base_it : fwd_in_it.second) { + set_input_vars.insert(var_base_it.get()); } } - for (auto& pair : outs) { - for (auto& var : pair.second) { - auto& var_ptr = name_to_var[var->Name()]; - PADDLE_ENFORCE_EQ(var_ptr == nullptr || var_ptr->get() == var.get(), true, - "There are different variables with same name %s", - var->Name()); - var_ptr = &var; + for (auto& fwd_out_it : outs) { + for (auto& var_base_it : fwd_out_it.second) { + set_input_vars.insert(var_base_it.get()); } } - // Build backward ins and outs - - for (size_t i = 0; i < grad_op_num; i++) { - // Step1: build grad op and add them to engine - - // Use trace id to decide the order of gradient sum in sorted sum mode + for (size_t i = 0; i < grad_op_num; ++i) { size_t trace_id = fwd_op->id(); - std::shared_ptr grad_op = - OpBase::Create(trace_id, (*(grad_op_descs_[i].get())), fwd_op->place()); - - // this OpBase* is just used to manage op's life time - engine_->InsertOp(grad_op.get(), grad_op); - - std::unordered_set visited_preceding_ops; - // Step2 : prepare grad_in vars and bind them with grad_op, - // set inputs' grad_op as current grad_op - for (const auto& grad_ins : grad_op_descs_[i]->Inputs()) { - if (grad_ins.second.empty()) continue; - auto& bwd_in = (*grad_op->GetMutableInsMap())[grad_ins.first]; - bwd_in.reserve(grad_ins.second.size()); - - for (auto& grad_in_var_name : grad_ins.second) { - auto iter = grad_to_var.find(grad_in_var_name); - if (iter != grad_to_var.end()) { - // If it is a grad var, find its coresponding forward var - auto& fwd_var_name = iter->second; - auto fwd_var_iter = name_to_var.find(fwd_var_name); - PADDLE_ENFORCE_EQ(fwd_var_iter != name_to_var.end(), true, - "Cannot find forward variable named %s", - fwd_var_name); - const auto& tmp = (*(fwd_var_iter->second))->GradVarBase(); - PADDLE_ENFORCE_NOT_NULL( - tmp.get(), - "Grad of %s should " - "not be NULL when we Track_Backward Input of %s", - (*(fwd_var_iter->second))->Name(), grad_op->Type()); - // Create grad_in's dim in tensor for Grad Dependency compute - auto* tensor = tmp->MutableVar()->GetMutable(); - tensor->Resize((*(fwd_var_iter->second)) - ->Var() - .Get() - .dims()); - // Add Grad Op for grad_in - tmp->AddGradOps(grad_op); - VLOG(3) << "Add Grad Op " << grad_op->Type() << " for :" - << (*(fwd_var_iter->second))->GradVarBase()->Name(); - // Add Grad var input to engine set - engine_->InsertGradVar(tmp.get()); - VLOG(3) << "Add Grad: " << tmp->Name() << " in to Engine"; - bwd_in.emplace_back((*(fwd_var_iter->second))->GradVarBase()); - } else { - // If it is a forward var, just add it - auto fwd_var_iter = name_to_var.find(grad_in_var_name); - PADDLE_ENFORCE_EQ(fwd_var_iter != name_to_var.end(), true, - "Cannot find forward variable named %s", - grad_in_var_name); - bwd_in.emplace_back(*(fwd_var_iter->second)); + std::shared_ptr grad_op = std::move(grad_op_bases_[i]); + grad_op->SetId(trace_id); + grad_op->SetPlace(fwd_op->place()); + grad_op->CreateOperatorBase(); + + auto& grad_in = *(grad_op->GetMutableInsMap()); + auto& grad_out = *(grad_op->GetMutableOutsMap()); + for (auto& grad_in_it : grad_in) { + for (auto& var_base_it : grad_in_it.second) { + if (set_input_vars.count(var_base_it.get()) == 0) { + var_base_it->AddGradOps(grad_op); + engine_->InsertGradVar(var_base_it.get()); } - VLOG(3) << "Set backward input from fwd var" << grad_ins.first << " of " - << grad_op->Type() << " to be " - << (bwd_in.back() ? bwd_in.back()->Name() : "nullptr"); } } - // Step3: prepare grad_out vars and using their grad_ops to set current - // grad_op's preceding op - for (auto& grad_outs : grad_op_descs_[i]->Outputs()) { - if (grad_outs.second.empty()) continue; - auto& bwd_out = (*grad_op->GetMutableOutsMap())[grad_outs.first]; - bwd_out.reserve(grad_outs.second.size()); - - for (auto& grad_out_var_name : grad_outs.second) { - auto iter = grad_to_var.find(grad_out_var_name); - PADDLE_ENFORCE_EQ(iter != grad_to_var.end(), true, - "Cannot find output of input grad %s in op %s", - grad_out_var_name, fwd_op->Type()); - auto fwd_var_iter = name_to_var.find(iter->second); - PADDLE_ENFORCE_EQ(fwd_var_iter != name_to_var.end(), true, - "Cannot find forward variable named %s", - iter->second); - const auto& tmp = (*(fwd_var_iter->second))->GradVarBase(); - - PADDLE_ENFORCE_NOT_NULL(tmp.get(), - "Grad output: %s of op: %s should not be NULL", - (tmp->Name(), grad_op->Type())); - - if ((!tmp->OverridedStopGradient()) || (grad_outs.second.size() > 1)) { - VLOG(3) << "Set backward output " << grad_outs.first << " of " - << grad_op->Type() << " to be " << tmp->Name() - << ". Its Overrided Stop_Gradient is: False"; - bwd_out.emplace_back(tmp); - auto grad_pending_ops = - (*(fwd_var_iter->second))->GradVarBase()->GradOps(); - if (VLOG_IS_ON(3) && !grad_pending_ops.empty()) { - VLOG(3) << "Add grad_pending Op of :" - << (*(fwd_var_iter->second))->GradVarBase()->Name() - << " It's grad_pending Op are: "; - for (const auto& op : grad_pending_ops) { - VLOG(3) << op->Type(); - } - } - auto grad_name = (*(fwd_var_iter->second))->GradVarBase()->Name(); - if (!grad_pending_ops.empty()) { - for (const auto& op : grad_pending_ops) { - PADDLE_ENFORCE_NOT_NULL( - op, "No nullptr should be grad_pending op for variable %s ", - grad_name); - if (visited_preceding_ops.count(op) == 0) { - visited_preceding_ops.insert(op); - grad_op->InsertGradPendingOps(op); - } + std::set visited_preceding_ops; + for (auto& grad_out_it : grad_out) { + bool flag_clear_list = false; + for (auto& var_base_it : grad_out_it.second) { + if ((!var_base_it->OverridedStopGradient()) || + (grad_out_it.second.size() > 1)) { + auto preceding_ops = var_base_it->GradOps(); + if (!preceding_ops.empty()) { + for (const auto& op : preceding_ops) { + visited_preceding_ops.insert(op); } - } else { - VLOG(5) << "Hit leaf VarBase" - << (*(fwd_var_iter->second))->GradVarBase()->Name(); } } else { - VLOG(3) << "Skip backward output " << grad_outs.first << " of " - << grad_op->Type() << " Named: " << tmp->Name() - << ", since its Overrided Stop_Gradient is: True"; + flag_clear_list = true; } } + if (flag_clear_list) { + grad_out_it.second.clear(); + } } - // To ensure numeric stability as static graph - grad_op->SortGradPendingOps(); + std::vector vec_preceding_ops(visited_preceding_ops.begin(), + visited_preceding_ops.end()); + + grad_op->SetGradPendingOps(std::move(vec_preceding_ops)); + + // this OpBase* is just used to manage op's life time + engine_->InsertOp(grad_op.get(), grad_op); } } diff --git a/paddle/fluid/imperative/tracer.h b/paddle/fluid/imperative/tracer.h index 7bddea53f15a15ebcbb7c3d1a2fb36a87c8a015f..b58f2a817476695598f35f4227e52e8f09476139 100644 --- a/paddle/fluid/imperative/tracer.h +++ b/paddle/fluid/imperative/tracer.h @@ -60,7 +60,6 @@ class Tracer { const NameVarBaseMap& outs, bool trace_backward); void TraceBackward(const std::shared_ptr& fwd_op, - const framework::OpDesc& fwd_op_desc, const NameVarBaseMap& ins, const NameVarBaseMap& outs); Engine* GetDefaultEngine() const { return engine_.get(); } diff --git a/paddle/fluid/operators/activation_op.cc b/paddle/fluid/operators/activation_op.cc index be4786fadaf56e2dd0076ba3929d2e03a7364821..60cf56451895261f047dba40751fde76c69a284e 100644 --- a/paddle/fluid/operators/activation_op.cc +++ b/paddle/fluid/operators/activation_op.cc @@ -62,29 +62,29 @@ static constexpr bool CanInplaceAct() { } \ } -template -class ActivationGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class ActivationGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); - op->SetType(ForwardOpType() + "_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); + op->SetType(this->ForwardOpType() + "_grad"); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); if ((static_cast(kDepValue) & static_cast(ActBwdOpFwdDeps::kDepX)) || FLAGS_use_mkldnn || (op->HasAttr("use_mkldnn") && boost::get(op->GetAttr("use_mkldnn")))) { - op->SetInput("X", Input("X")); + op->SetInput("X", this->Input("X")); } if (static_cast(kDepValue) & static_cast(ActBwdOpFwdDeps::kDepOut)) { - op->SetInput("Out", Output("Out")); + op->SetInput("Out", this->Output("Out")); } return op; @@ -721,91 +721,94 @@ class ActivationOpDoubleGrad2 : public framework::OperatorWithKernel { // ReluGrad: dx = dy if y >= 0 else 0 // ReluGradGrad: ddy = ddx if y >= 0 else 0 // -class ReluDoubleGradMaker : public ::paddle::framework::SingleGradOpDescMaker { +template +class ReluDoubleGradMaker : public ::paddle::framework::SingleGradOpMaker { public: - using ::paddle::framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using ::paddle::framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr<::paddle::framework::OpDesc> Apply() const override { - auto* op = new ::paddle::framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("relu_grad_grad"); // input1: Out - op->SetInput("Out", Input("Out")); + op->SetInput("Out", this->Input("Out")); // input2: ddx - op->SetInput("DDX", OutputGrad(framework::GradVarName("X"))); - op->SetAttrMap(Attrs()); + op->SetInput("DDX", this->OutputGrad(framework::GradVarName("X"))); + op->SetAttrMap(this->Attrs()); // output: ddy - op->SetOutput("DDOut", InputGrad(framework::GradVarName("Out"))); - return std::unique_ptr<::paddle::framework::OpDesc>(op); + op->SetOutput("DDOut", this->InputGrad(framework::GradVarName("Out"))); + return std::unique_ptr(op); } }; // leaky_relu Grad: dx=dy if y>=0 else alpha * dy // leaky_relu GradGrad: ddy=ddx if y>=0 else alpha * ddx +template class LeakyReluDoubleGradMaker - : public ::paddle::framework::SingleGradOpDescMaker { + : public ::paddle::framework::SingleGradOpMaker { public: - using ::paddle::framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using ::paddle::framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr<::paddle::framework::OpDesc> Apply() const override { - auto* op = new ::paddle::framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("leaky_relu_grad_grad"); // input1: Out - op->SetInput("Out", Input("Out")); + op->SetInput("Out", this->Input("Out")); // X@GRAD@GRAD: ddx - op->SetInput("DDX", OutputGrad(framework::GradVarName("X"))); - op->SetAttrMap(Attrs()); + op->SetInput("DDX", this->OutputGrad(framework::GradVarName("X"))); + op->SetAttrMap(this->Attrs()); // Out@GRAD@GRAD: ddy - op->SetOutput("DDOut", InputGrad(framework::GradVarName("Out"))); - return std::unique_ptr<::paddle::framework::OpDesc>(op); + op->SetOutput("DDOut", this->InputGrad(framework::GradVarName("Out"))); + return std::unique_ptr(op); } }; // sqrt Grad: dx = 0.5 * dy / y // sqrt GradGrad: ddy = 0.5 * ddx / y, dy = -1 * dx * ddx -class SqrtDoubleGradMaker : public ::paddle::framework::SingleGradOpDescMaker { +template +class SqrtDoubleGradMaker : public ::paddle::framework::SingleGradOpMaker { public: - using ::paddle::framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using ::paddle::framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr<::paddle::framework::OpDesc> Apply() const override { - auto* op = new ::paddle::framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("sqrt_grad_grad"); - op->SetInput("Out", Input("Out")); - op->SetInput("DX", Output(framework::GradVarName("X"))); - op->SetInput("DDX", OutputGrad(framework::GradVarName("X"))); - op->SetAttrMap(Attrs()); - op->SetOutput("DOut", InputGrad("Out")); - op->SetOutput("DDOut", InputGrad(framework::GradVarName("Out"))); - return std::unique_ptr<::paddle::framework::OpDesc>(op); + op->SetInput("Out", this->Input("Out")); + op->SetInput("DX", this->Output(framework::GradVarName("X"))); + op->SetInput("DDX", this->OutputGrad(framework::GradVarName("X"))); + op->SetAttrMap(this->Attrs()); + op->SetOutput("DOut", this->InputGrad("Out")); + op->SetOutput("DDOut", this->InputGrad(framework::GradVarName("Out"))); + return std::unique_ptr(op); } }; // square Grad: dx=2x*dy // square GradGrad: ddy=2x*ddx, dx=2dy*ddx -class SquareDoubleGradMaker - : public ::paddle::framework::SingleGradOpDescMaker { +template +class SquareDoubleGradMaker : public ::paddle::framework::SingleGradOpMaker { public: - using ::paddle::framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using ::paddle::framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr<::paddle::framework::OpDesc> Apply() const override { - auto* op = new ::paddle::framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("square_grad_grad"); - op->SetInput("X", Input("X")); + op->SetInput("X", this->Input("X")); // Out@GRAD: dy - op->SetInput("DOut", Input(framework::GradVarName("Out"))); + op->SetInput("DOut", this->Input(framework::GradVarName("Out"))); // X@GRAD@GRAD: ddx - op->SetInput("DDX", OutputGrad(framework::GradVarName("X"))); + op->SetInput("DDX", this->OutputGrad(framework::GradVarName("X"))); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); // X@GRAD: dx - op->SetOutput("DX", InputGrad("X")); + op->SetOutput("DX", this->InputGrad("X")); // Out@GRAD@GRAD: ddy - op->SetOutput("DDOut", InputGrad(framework::GradVarName("Out"))); - return std::unique_ptr<::paddle::framework::OpDesc>(op); + op->SetOutput("DDOut", this->InputGrad(framework::GradVarName("Out"))); + return std::unique_ptr(op); } }; @@ -815,19 +818,20 @@ DECLARE_INPLACE_OP_INFERER(ActivationGradOpInplaceInference, DECLARE_INPLACE_OP_INFERER(ActivationDoubleGradOpInplaceInference, {"DDX", "DDOut"}); -class PowGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class PowGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("pow_grad"); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetInput("FactorTensor", Input("FactorTensor")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetInput("FactorTensor", this->Input("FactorTensor")); + op->SetAttrMap(this->Attrs()); return op; } @@ -894,7 +898,10 @@ namespace plat = paddle::platform; REGISTER_OPERATOR( \ KERNEL_TYPE, ops::ActivationOp, ops::OP_NAME##OpMaker, \ ops::ActivationOpInferVarType, \ - ops::ActivationGradOpDescMaker::FwdDeps()>, \ + ops::ActivationGradOpMaker::FwdDeps(), \ + paddle::framework::OpDesc>, \ + ops::ActivationGradOpMaker::FwdDeps(), \ + paddle::imperative::OpBase>, \ std::conditional>(), \ ::paddle::framework::SingleOpInplaceInToOut, \ void>::type); \ @@ -921,11 +928,15 @@ FOR_EACH_ACTIVATION_OP(REGISTER_ACTIVATION_CPU_KERNEL); /* ========================== relu register ============================= */ REGISTER_OPERATOR( relu, ops::ActivationOp, ops::ReluOpMaker, ops::ActivationOpInferVarType, - ops::ActivationGradOpDescMaker::FwdDeps()>, + ops::ActivationGradOpMaker::FwdDeps(), + paddle::framework::OpDesc>, + ops::ActivationGradOpMaker::FwdDeps(), + paddle::imperative::OpBase>, paddle::framework::SingleOpInplaceInToOut); REGISTER_OPERATOR(relu_grad, ops::ActivationOpGrad, ops::ActivationGradOpInplaceInference, - ops::ReluDoubleGradMaker); + ops::ReluDoubleGradMaker, + ops::ReluDoubleGradMaker); REGISTER_OPERATOR( relu_grad_grad, ops::ActivationOpDoubleGrad2::FwdDeps()>, @@ -947,11 +958,15 @@ REGISTER_OP_CPU_KERNEL( REGISTER_OPERATOR( leaky_relu, ops::ActivationOp, ops::LeakyReluOpMaker, ops::ActivationOpInferVarType, - ops::ActivationGradOpDescMaker::FwdDeps()>, + ops::ActivationGradOpMaker::FwdDeps(), + paddle::framework::OpDesc>, + ops::ActivationGradOpMaker::FwdDeps(), + paddle::imperative::OpBase>, paddle::framework::SingleOpInplaceInToOut); REGISTER_OPERATOR(leaky_relu_grad, ops::ActivationOpGrad, ops::ActivationGradOpInplaceInference, - ops::LeakyReluDoubleGradMaker); + ops::LeakyReluDoubleGradMaker, + ops::LeakyReluDoubleGradMaker); REGISTER_OPERATOR( leaky_relu_grad_grad, ops::ActivationOpDoubleGrad2::FwdDeps()>, @@ -972,11 +987,15 @@ REGISTER_OP_CPU_KERNEL( /* =========================== sqrt register ============================= */ REGISTER_OPERATOR( sqrt, ops::ActivationOp, ops::SqrtOpMaker, ops::ActivationOpInferVarType, - ops::ActivationGradOpDescMaker::FwdDeps()>, + ops::ActivationGradOpMaker::FwdDeps(), + paddle::framework::OpDesc>, + ops::ActivationGradOpMaker::FwdDeps(), + paddle::imperative::OpBase>, paddle::framework::SingleOpInplaceInToOut); REGISTER_OPERATOR(sqrt_grad, ops::ActivationOpGrad, ops::ActivationGradOpInplaceInference, - ops::SqrtDoubleGradMaker); + ops::SqrtDoubleGradMaker, + ops::SqrtDoubleGradMaker); REGISTER_OPERATOR( sqrt_grad_grad, ops::ActivationOpDoubleGrad::FwdDeps()>, @@ -996,11 +1015,15 @@ REGISTER_OP_CPU_KERNEL( REGISTER_OPERATOR( square, ops::ActivationOp, ops::SquareOpMaker, ops::ActivationOpInferVarType, - ops::ActivationGradOpDescMaker::FwdDeps()>, + ops::ActivationGradOpMaker::FwdDeps(), + paddle::framework::OpDesc>, + ops::ActivationGradOpMaker::FwdDeps(), + paddle::imperative::OpBase>, paddle::framework::SingleOpInplaceInToOut); REGISTER_OPERATOR(square_grad, ops::ActivationOpGrad, ops::ActivationGradOpInplaceInference, - ops::SquareDoubleGradMaker); + ops::SquareDoubleGradMaker, + ops::SquareDoubleGradMaker); REGISTER_OPERATOR( square_grad_grad, ops::ActivationOpDoubleGrad::FwdDeps()>, @@ -1023,7 +1046,8 @@ REGISTER_OP_CPU_KERNEL( REGISTER_OPERATOR( pow, ops::PowOp, ops::PowOpMaker, ops::ActivationOpInferVarType, - ops::PowGradOpDescMaker, + ops::PowGradOpMaker, + ops::PowGradOpMaker, std::conditional>(), ::paddle::framework::SingleOpInplaceInToOut, void>::type); REGISTER_OPERATOR(pow_grad, ops::PowOpGrad, diff --git a/paddle/fluid/operators/add_position_encoding_op.cc b/paddle/fluid/operators/add_position_encoding_op.cc index 61a9fa765079d313a5b93c82d97658ae87fa4f8e..30dfd683a04c4de7c81f734273f0316c0e264aa4 100644 --- a/paddle/fluid/operators/add_position_encoding_op.cc +++ b/paddle/fluid/operators/add_position_encoding_op.cc @@ -87,18 +87,18 @@ class AddPositionEncodingOpMaker : public framework::OpProtoAndCheckerMaker { } }; -class AddPositionEncodingGradOpDescMaker - : public framework::SingleGradOpDescMaker { +template +class AddPositionEncodingGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("add_position_encoding_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -109,9 +109,11 @@ class AddPositionEncodingGradOpDescMaker namespace ops = paddle::operators; namespace plt = paddle::platform; -REGISTER_OPERATOR(add_position_encoding, ops::AddPositionEncodingOp, - ops::AddPositionEncodingOpMaker, - ops::AddPositionEncodingGradOpDescMaker); +REGISTER_OPERATOR( + add_position_encoding, ops::AddPositionEncodingOp, + ops::AddPositionEncodingOpMaker, + ops::AddPositionEncodingGradOpMaker, + ops::AddPositionEncodingGradOpMaker); REGISTER_OPERATOR(add_position_encoding_grad, ops::AddPositionEncodingOpGrad); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/affine_channel_op.cc b/paddle/fluid/operators/affine_channel_op.cc index 6040ed7550d9482f1d56c537dbcd3c802e5976c8..420ef4d75acf896de8f1e2f32ec5fe88d25e99da 100644 --- a/paddle/fluid/operators/affine_channel_op.cc +++ b/paddle/fluid/operators/affine_channel_op.cc @@ -127,24 +127,25 @@ class AffineChannelOpGrad : public framework::OperatorWithKernel { } }; -class AffineChannelGradMaker : public framework::SingleGradOpDescMaker { +template +class AffineChannelGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("affine_channel_grad"); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput("Scale", Input("Scale")); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput("Scale", this->Input("Scale")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Scale"), InputGrad("Scale")); - op->SetOutput(framework::GradVarName("Bias"), InputGrad("Bias")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Scale"), this->InputGrad("Scale")); + op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); - return std::unique_ptr(op); + return std::unique_ptr(op); } }; @@ -331,7 +332,9 @@ namespace ops = paddle::operators; using CPU = paddle::platform::CPUDeviceContext; REGISTER_OPERATOR(affine_channel, ops::AffineChannelOp, - ops::AffineChannelOpMaker, ops::AffineChannelGradMaker, + ops::AffineChannelOpMaker, + ops::AffineChannelGradMaker, + ops::AffineChannelGradMaker, ops::AffineChannelInplaceInferer); REGISTER_OPERATOR(affine_channel_grad, ops::AffineChannelOpGrad, ops::AffineChannelNoNeedBufferVarsInference, diff --git a/paddle/fluid/operators/affine_grid_op.cc b/paddle/fluid/operators/affine_grid_op.cc index c46b42601156e2471877b563c52a32a59e2134be..959af025c33cd4a7efd57e92950145374961914c 100644 --- a/paddle/fluid/operators/affine_grid_op.cc +++ b/paddle/fluid/operators/affine_grid_op.cc @@ -197,22 +197,23 @@ class AffineGridOpGrad : public framework::OperatorWithKernel { } }; -class AffineGridGradMaker : public framework::SingleGradOpDescMaker { +template +class AffineGridGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("affine_grid_grad"); - op->SetInput("Theta", Input("Theta")); - op->SetInput("OutputShape", Input("OutputShape")); - op->SetInput(framework::GradVarName("Output"), OutputGrad("Output")); + op->SetInput("Theta", this->Input("Theta")); + op->SetInput("OutputShape", this->Input("OutputShape")); + op->SetInput(framework::GradVarName("Output"), this->OutputGrad("Output")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput(framework::GradVarName("Theta"), InputGrad("Theta")); - return std::unique_ptr(op); + op->SetOutput(framework::GradVarName("Theta"), this->InputGrad("Theta")); + return std::unique_ptr(op); } }; @@ -221,7 +222,8 @@ class AffineGridGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(affine_grid, ops::AffineGridOp, ops::AffineGridOpMaker, - ops::AffineGridGradMaker); + ops::AffineGridGradMaker, + ops::AffineGridGradMaker); REGISTER_OPERATOR(affine_grid_grad, ops::AffineGridOpGrad); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/arg_max_op.cc b/paddle/fluid/operators/arg_max_op.cc index 7fe9a0df7467970286fb0efc7c5ce7aaf01ac28b..fd7fa17ac9ae5e540176bb583cf87fa3d00d2945 100644 --- a/paddle/fluid/operators/arg_max_op.cc +++ b/paddle/fluid/operators/arg_max_op.cc @@ -14,9 +14,10 @@ limitations under the License. */ #include "paddle/fluid/operators/arg_min_max_op_base.h" -REGISTER_OPERATOR(arg_max, paddle::operators::ArgMinMaxOp, - paddle::operators::ArgMaxOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + arg_max, paddle::operators::ArgMinMaxOp, paddle::operators::ArgMaxOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( arg_max, diff --git a/paddle/fluid/operators/arg_min_op.cc b/paddle/fluid/operators/arg_min_op.cc index 23b24735cd0ba17afd30b95c329cb0530a1f0104..74fc3292746d26a983fa81ed8cac67b30e23d476 100644 --- a/paddle/fluid/operators/arg_min_op.cc +++ b/paddle/fluid/operators/arg_min_op.cc @@ -14,9 +14,10 @@ limitations under the License. */ #include "paddle/fluid/operators/arg_min_max_op_base.h" -REGISTER_OPERATOR(arg_min, paddle::operators::ArgMinMaxOp, - paddle::operators::ArgMinOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + arg_min, paddle::operators::ArgMinMaxOp, paddle::operators::ArgMinOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( arg_min, diff --git a/paddle/fluid/operators/argsort_op.cc b/paddle/fluid/operators/argsort_op.cc index d25160f4232b5a621d16b9f469f56bd5aa7c88e3..57c2a3ba7b8b65e67ea95642d17c8ab85f33b62c 100644 --- a/paddle/fluid/operators/argsort_op.cc +++ b/paddle/fluid/operators/argsort_op.cc @@ -80,8 +80,10 @@ Output(Indices) gives the sorted order along the given axis Attr(axis). } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(argsort, ops::ArgsortOp, ops::ArgsortOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + argsort, ops::ArgsortOp, ops::ArgsortOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(argsort, ops::ArgsortKernel, ops::ArgsortKernel); diff --git a/paddle/fluid/operators/array_to_lod_tensor_op.cc b/paddle/fluid/operators/array_to_lod_tensor_op.cc index 7b5a270ee0750528b68379bdb50e587b672683b9..0f258f4a5e7ce63ce7fb221fdae14408f96b57e5 100644 --- a/paddle/fluid/operators/array_to_lod_tensor_op.cc +++ b/paddle/fluid/operators/array_to_lod_tensor_op.cc @@ -210,19 +210,20 @@ class ArrayToLoDTensorInferShape : public framework::InferShapeBase { } }; -class ArrayToLoDTensorGradMaker : public framework::SingleGradOpDescMaker { +template +class ArrayToLoDTensorGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("lod_tensor_to_array"); - grad_op->SetInput("X", OutputGrad("Out")); - grad_op->SetInput("RankTable", Input("RankTable")); - grad_op->SetOutput("Out", InputGrad("X")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("X", this->OutputGrad("Out")); + grad_op->SetInput("RankTable", this->Input("RankTable")); + grad_op->SetOutput("Out", this->InputGrad("X")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -233,4 +234,5 @@ namespace ops = paddle::operators; REGISTER_OPERATOR(array_to_lod_tensor, ops::ArrayToLoDTensorOp, ops::ArrayToLoDTensorOpProtoMaker, ops::ArrayToLoDTensorInferShape, - ops::ArrayToLoDTensorGradMaker); + ops::ArrayToLoDTensorGradMaker, + ops::ArrayToLoDTensorGradMaker); diff --git a/paddle/fluid/operators/assign_op.cc b/paddle/fluid/operators/assign_op.cc index c2b3c818c65e3902054ee67c2d291d308db9ee13..315982ec8fb49765db8a7a21a0810cbb6b58339f 100644 --- a/paddle/fluid/operators/assign_op.cc +++ b/paddle/fluid/operators/assign_op.cc @@ -131,17 +131,18 @@ raise error if the type is not listed above. } }; -class AssignGradMaker : public framework::SingleGradOpDescMaker { +template +class AssignGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *op = new T(); op->SetType("assign"); - op->SetInput("X", OutputGrad("Out")); - op->SetOutput("Out", InputGrad("X")); - return std::unique_ptr(op); + op->SetInput("X", this->OutputGrad("Out")); + op->SetOutput("Out", this->InputGrad("X")); + return std::unique_ptr(op); } }; @@ -151,8 +152,11 @@ DECLARE_INPLACE_OP_INFERER(AssignOpInplaceInferer, {"X", "Out"}); } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(assign, ops::AssignOp, ops::AssignGradMaker, +REGISTER_OPERATOR(assign, ops::AssignOp, + ops::AssignGradMaker, + ops::AssignGradMaker, ops::AssignOpProtoMaker, ops::AssignOpInplaceInferer); + REGISTER_OP_CPU_KERNEL_FUNCTOR(assign, float, ops::AssignKernel, double, ops::AssignKernel, int, ops::AssignKernel, int64_t, ops::AssignKernel, bool, diff --git a/paddle/fluid/operators/assign_value_op.cc b/paddle/fluid/operators/assign_value_op.cc index a757916be7f6ece9b783d51d1051aac6a276795b..456cbee923aa1a406db6fe364edcc139a44ed282 100644 --- a/paddle/fluid/operators/assign_value_op.cc +++ b/paddle/fluid/operators/assign_value_op.cc @@ -70,7 +70,9 @@ $$Out = values$$ namespace ops = paddle::operators; -REGISTER_OPERATOR(assign_value, ops::AssignValueOp, ops::AssignValueOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + assign_value, ops::AssignValueOp, ops::AssignValueOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(assign_value, ops::AssignValueKernel, ops::AssignValueKernel); diff --git a/paddle/fluid/operators/average_accumulates_op.cc b/paddle/fluid/operators/average_accumulates_op.cc index 273df31fc80c43873bdb333c971ff37d44bce500..5b3dbcd65ec58e45a964cc170aefbbadf258813a 100644 --- a/paddle/fluid/operators/average_accumulates_op.cc +++ b/paddle/fluid/operators/average_accumulates_op.cc @@ -205,9 +205,11 @@ And for a mini-batch in training, accumulators were computed as below steps: } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(average_accumulates, ops::AverageAccumulatesOp, - ops::AverageAccumulatesOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + average_accumulates, ops::AverageAccumulatesOp, + ops::AverageAccumulatesOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( average_accumulates, ops::AverageAccumulatesKernel, diff --git a/paddle/fluid/operators/batch_norm_op.cc b/paddle/fluid/operators/batch_norm_op.cc index 546605c8dba2fbd455f2f8dfcefb0c1f23a69d33..bc0f16a96621a7b2f3e33dfe9f14daf6ec4db338 100644 --- a/paddle/fluid/operators/batch_norm_op.cc +++ b/paddle/fluid/operators/batch_norm_op.cc @@ -613,38 +613,47 @@ class BatchNormGradKernel } }; -std::unique_ptr BatchNormGradMaker::Apply() const { - auto *op = new framework::OpDesc(); - op->SetType(GradOpType()); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - - op->SetInput("Scale", Input("Scale")); - op->SetInput("Bias", Input("Bias")); - op->SetInput("SavedMean", Output("SavedMean")); - op->SetInput("SavedVariance", Output("SavedVariance")); - - // used when setting use_global_stats True during training - if (boost::get(GetAttr("use_global_stats"))) { - op->SetInput("Mean", Output("MeanOut")); - op->SetInput("Variance", Output("VarianceOut")); - } +template +class BatchNormGradMaker : public framework::SingleGradOpMaker { + public: + using framework::SingleGradOpMaker::SingleGradOpMaker; + + protected: + std::unique_ptr Apply() const override { + auto *op = new T(); + op->SetType(this->ForwardOpType() + "_grad"); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + + op->SetInput("Scale", this->Input("Scale")); + op->SetInput("Bias", this->Input("Bias")); + op->SetInput("SavedMean", this->Output("SavedMean")); + op->SetInput("SavedVariance", this->Output("SavedVariance")); + + // used when setting use_global_stats True during training + if (boost::get(this->GetAttr("use_global_stats"))) { + op->SetInput("Mean", this->Output("MeanOut")); + op->SetInput("Variance", this->Output("VarianceOut")); + } - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Scale"), InputGrad("Scale")); - op->SetOutput(framework::GradVarName("Bias"), InputGrad("Bias")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Scale"), this->InputGrad("Scale")); + op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); - return std::unique_ptr(op); -} + return std::unique_ptr(op); + } +}; } // namespace operators } // namespace paddle namespace ops = paddle::operators; REGISTER_OPERATOR(batch_norm, ops::BatchNormOp, ops::BatchNormOpMaker, - ops::BatchNormOpInferVarType, ops::BatchNormGradMaker); + ops::BatchNormOpInferVarType, + ops::BatchNormGradMaker, + ops::BatchNormGradMaker); REGISTER_OPERATOR(batch_norm_grad, ops::BatchNormGradOp); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/batch_norm_op.h b/paddle/fluid/operators/batch_norm_op.h index 6c7dbe0db4e3545200ff77c9331b6b656d9de2ea..4746a1d2cf1ade7d33e344e248dda169a514ca3f 100644 --- a/paddle/fluid/operators/batch_norm_op.h +++ b/paddle/fluid/operators/batch_norm_op.h @@ -64,18 +64,6 @@ class BatchNormOpMaker : public framework::OpProtoAndCheckerMaker { void Make() override; }; -class BatchNormGradMaker : public framework::SingleGradOpDescMaker { - public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; - - protected: - std::unique_ptr Apply() const override; - - virtual std::string GradOpType() const { - return this->ForwardOpType() + "_grad"; - } -}; - class BatchNormOpInferVarType : public framework::PassInDtypeAndVarTypeToOutput { protected: diff --git a/paddle/fluid/operators/beam_search_decode_op.cc b/paddle/fluid/operators/beam_search_decode_op.cc index 4cef49280dfb5207a9d94df42d94657f03ec838f..5eec87887acdf37f32800b1c65b51c9bd5b325f0 100644 --- a/paddle/fluid/operators/beam_search_decode_op.cc +++ b/paddle/fluid/operators/beam_search_decode_op.cc @@ -216,8 +216,10 @@ class BeamSearchDecodeInferVarType : public framework::VarTypeInference { } // namespace operators } // namespace paddle -REGISTER_OPERATOR(beam_search_decode, paddle::operators::BeamSearchDecodeOp, - paddle::operators::BeamSearchDecodeOpProtoMaker, - paddle::operators::BeamSearchDecodeInferShape, - paddle::operators::BeamSearchDecodeInferVarType, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + beam_search_decode, paddle::operators::BeamSearchDecodeOp, + paddle::operators::BeamSearchDecodeOpProtoMaker, + paddle::operators::BeamSearchDecodeInferShape, + paddle::operators::BeamSearchDecodeInferVarType, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/bilinear_tensor_product_op.cc b/paddle/fluid/operators/bilinear_tensor_product_op.cc index f2c30cd7e8c6674866b8dfa482f1bc5195f689c2..235a8deb99bde37054241e80720f449e4ade00de 100644 --- a/paddle/fluid/operators/bilinear_tensor_product_op.cc +++ b/paddle/fluid/operators/bilinear_tensor_product_op.cc @@ -147,27 +147,28 @@ class BilinearTensorProductOpGrad : public framework::OperatorWithKernel { } }; -class BilinearTensorProductGradOpDescMaker - : public framework::SingleGradOpDescMaker { +template +class BilinearTensorProductGradOpMaker + : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("bilinear_tensor_product_grad"); - op->SetAttrMap(Attrs()); - op->SetInput("X", Input("X")); - op->SetInput("Y", Input("Y")); - op->SetInput("Weight", Input("Weight")); - if (ForwardOp().Inputs().count("Bias") > 0) { - op->SetOutput(framework::GradVarName("Bias"), InputGrad("Bias")); + op->SetAttrMap(this->Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Y", this->Input("Y")); + op->SetInput("Weight", this->Input("Weight")); + if (this->HasInput("Bias")) { + op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); } - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); - op->SetOutput(framework::GradVarName("Weight"), InputGrad("Weight")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); + op->SetOutput(framework::GradVarName("Weight"), this->InputGrad("Weight")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); return op; } @@ -177,9 +178,11 @@ class BilinearTensorProductGradOpDescMaker } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(bilinear_tensor_product, ops::BilinearTensorProductOp, - ops::BilinearTensorProductOpMaker, - ops::BilinearTensorProductGradOpDescMaker); +REGISTER_OPERATOR( + bilinear_tensor_product, ops::BilinearTensorProductOp, + ops::BilinearTensorProductOpMaker, + ops::BilinearTensorProductGradOpMaker, + ops::BilinearTensorProductGradOpMaker); REGISTER_OPERATOR(bilinear_tensor_product_grad, ops::BilinearTensorProductOpGrad); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/bpr_loss_op.cc b/paddle/fluid/operators/bpr_loss_op.cc index 1ad0271304929452f665d287e161917ebd9d1b71..c0985abecac2988278c5ccc6c5d3d3b51d3b2d7e 100644 --- a/paddle/fluid/operators/bpr_loss_op.cc +++ b/paddle/fluid/operators/bpr_loss_op.cc @@ -135,19 +135,20 @@ neural networks>(https://arxiv.org/abs/1511.06939) } }; -class BprLossGradDescMaker : public framework::SingleGradOpDescMaker { +template +class BprLossGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("bpr_loss_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Label", Input("Label")); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Label", this->Input("Label")); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -158,7 +159,8 @@ namespace ops = paddle::operators; using CPUCtx = paddle::platform::CPUDeviceContext; REGISTER_OPERATOR(bpr_loss, ops::BprLossOp, ops::BprLossOpMaker, - ops::BprLossGradDescMaker); + ops::BprLossGradMaker, + ops::BprLossGradMaker); REGISTER_OPERATOR(bpr_loss_grad, ops::BprLossGradientOp); REGISTER_OP_CPU_KERNEL(bpr_loss, ops::BprLossOpKernel, ops::BprLossOpKernel); diff --git a/paddle/fluid/operators/cast_op.cc b/paddle/fluid/operators/cast_op.cc index 0c517cc757ca3f6f1ff7f4191ab2d529890b7154..c7a6b50b2fac2e1fb302904bdcd134ad588175c5 100644 --- a/paddle/fluid/operators/cast_op.cc +++ b/paddle/fluid/operators/cast_op.cc @@ -49,19 +49,20 @@ class CastOpInferShape : public framework::InferShapeBase { } }; -class CastOpGradMaker : public framework::SingleGradOpDescMaker { +template +class CastOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto grad = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto grad = new T(); grad->SetType("cast"); - grad->SetInput("X", OutputGrad("Out")); - grad->SetOutput("Out", InputGrad("X")); - grad->SetAttr("out_dtype", GetAttr("in_dtype")); - grad->SetAttr("in_dtype", GetAttr("out_dtype")); - return std::unique_ptr(grad); + grad->SetInput("X", this->OutputGrad("Out")); + grad->SetOutput("Out", this->InputGrad("X")); + grad->SetAttr("out_dtype", this->GetAttr("in_dtype")); + grad->SetAttr("in_dtype", this->GetAttr("out_dtype")); + return std::unique_ptr(grad); } }; @@ -84,7 +85,9 @@ class CastOp : public framework::OperatorWithKernel { namespace ops = paddle::operators; using CPU = paddle::platform::CPUDeviceContext; -REGISTER_OPERATOR(cast, ops::CastOp, ops::CastOpGradMaker, +REGISTER_OPERATOR(cast, ops::CastOp, + ops::CastOpGradMaker, + ops::CastOpGradMaker, ops::CastOpInferShape, ops::CastOpProtoMaker); REGISTER_OP_CPU_KERNEL(cast, ops::CastOpKernel, ops::CastOpKernel, diff --git a/paddle/fluid/operators/center_loss_op.cc b/paddle/fluid/operators/center_loss_op.cc index 0b6ce82397384eed6ff2263822646f54c3500d97..f0c0a5e619f7c9234c02df492666ef52bfdfecac 100644 --- a/paddle/fluid/operators/center_loss_op.cc +++ b/paddle/fluid/operators/center_loss_op.cc @@ -123,20 +123,21 @@ class CenterLossGradOp : public framework::OperatorWithKernel { } }; -class CenterLossOpGradMaker : public framework::SingleGradOpDescMaker { +template +class CenterLossOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr retv(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr retv(new T()); retv->SetType("center_loss_grad"); - retv->SetInput(framework::GradVarName("Loss"), OutputGrad("Loss")); - retv->SetInput("SampleCenterDiff", Output("SampleCenterDiff")); - retv->SetInput("X", Input("X")); - retv->SetOutput(framework::GradVarName("X"), InputGrad("X")); + retv->SetInput(framework::GradVarName("Loss"), this->OutputGrad("Loss")); + retv->SetInput("SampleCenterDiff", this->Output("SampleCenterDiff")); + retv->SetInput("X", this->Input("X")); + retv->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); - retv->SetAttrMap(Attrs()); + retv->SetAttrMap(this->Attrs()); return retv; } }; @@ -147,7 +148,8 @@ namespace ops = paddle::operators; using CPUCtx = paddle::platform::CPUDeviceContext; REGISTER_OPERATOR(center_loss, ops::CenterLossOp, ops::CenterLossOpMaker, - ops::CenterLossOpGradMaker); + ops::CenterLossOpGradMaker, + ops::CenterLossOpGradMaker); REGISTER_OPERATOR(center_loss_grad, ops::CenterLossGradOp); diff --git a/paddle/fluid/operators/clip_op.cc b/paddle/fluid/operators/clip_op.cc index 408f960b53b74bdb2b790507b7576b3cd812e3bc..121fec1bb2737176874bdf038630512195daa93e 100644 --- a/paddle/fluid/operators/clip_op.cc +++ b/paddle/fluid/operators/clip_op.cc @@ -78,18 +78,19 @@ class ClipOpGrad : public framework::OperatorWithKernel { } }; -class ClipGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class ClipGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("clip_grad"); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -104,7 +105,9 @@ DECLARE_INPLACE_OP_INFERER(ClipGradInplaceInferer, namespace ops = paddle::operators; REGISTER_OPERATOR(clip, ops::ClipOp, ops::ClipOpMaker, - ops::ClipGradOpDescMaker, ops::ClipInplaceInferer); + ops::ClipGradOpMaker, + ops::ClipGradOpMaker, + ops::ClipInplaceInferer); REGISTER_OPERATOR(clip_grad, ops::ClipOpGrad, ops::ClipGradInplaceInferer); REGISTER_OP_CPU_KERNEL( clip, ops::ClipKernel, diff --git a/paddle/fluid/operators/collective/c_allgather_op.cc b/paddle/fluid/operators/collective/c_allgather_op.cc index 18c8f5d642332d96f6e76cf7f2e70b554cacbb89..8e54ec4ab211c793c8a169f158d90108061a5599 100644 --- a/paddle/fluid/operators/collective/c_allgather_op.cc +++ b/paddle/fluid/operators/collective/c_allgather_op.cc @@ -55,17 +55,18 @@ reference: https://docs.nvidia.com/deeplearning/sdk/nccl-developer-guide/docs/us } }; -class CAllGatherOpGradMaker : public framework::SingleGradOpDescMaker { +template +class CAllGatherOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr retv(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr retv(new T()); retv->SetType("c_reducescatter"); - retv->SetInput("X", OutputGrad("Out")); - retv->SetOutput("Out", InputGrad("X")); - retv->SetAttrMap(Attrs()); + retv->SetInput("X", this->OutputGrad("Out")); + retv->SetOutput("Out", this->InputGrad("X")); + retv->SetAttrMap(this->Attrs()); return retv; } }; @@ -76,7 +77,9 @@ class CAllGatherOpGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; namespace plat = paddle::platform; -REGISTER_OPERATOR(c_allgather, ops::CAllGatherOp, ops::CAllGatherOpGradMaker, +REGISTER_OPERATOR(c_allgather, ops::CAllGatherOp, + ops::CAllGatherOpGradMaker, + ops::CAllGatherOpGradMaker, ops::CAllGatherOpMaker); REGISTER_OP_CPU_KERNEL(c_allgather, ops::CAllGatherOpCPUKernel, diff --git a/paddle/fluid/operators/collective/c_allreduce_sum_op.cc b/paddle/fluid/operators/collective/c_allreduce_sum_op.cc index c80c585a83261f4b039289dd3419f5c7605d8767..51d6fb2b6e8d782ba6679cb469666172b1072889 100644 --- a/paddle/fluid/operators/collective/c_allreduce_sum_op.cc +++ b/paddle/fluid/operators/collective/c_allreduce_sum_op.cc @@ -17,17 +17,18 @@ limitations under the License. */ namespace paddle { namespace operators { -class CAllReduceSumOpGradMaker : public framework::SingleGradOpDescMaker { +template +class CAllReduceSumOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr retv(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr retv(new T()); retv->SetType("c_allreduce_sum"); - retv->SetInput("X", OutputGrad("Out")); - retv->SetOutput("Out", InputGrad("X")); - retv->SetAttrMap(Attrs()); + retv->SetInput("X", this->OutputGrad("Out")); + retv->SetOutput("Out", this->InputGrad("X")); + retv->SetAttrMap(this->Attrs()); return retv; } }; @@ -44,7 +45,9 @@ namespace ops = paddle::operators; namespace plat = paddle::platform; REGISTER_OPERATOR(c_allreduce_sum, ops::CAllReduceOp, - ops::CAllReduceSumOpGradMaker, ops::CAllReduceSumOpMaker); + ops::CAllReduceSumOpGradMaker, + ops::CAllReduceSumOpGradMaker, + ops::CAllReduceSumOpMaker); REGISTER_OP_CPU_KERNEL(c_allreduce_sum, ops::CAllReduceOpCPUKernel, diff --git a/paddle/fluid/operators/collective/c_reducescatter_op.cc b/paddle/fluid/operators/collective/c_reducescatter_op.cc index 1194ac71b32b4e61adf299cfbda0949d4823da90..959c164dec2eb1a82b1811cbeb01dc1419217fb5 100644 --- a/paddle/fluid/operators/collective/c_reducescatter_op.cc +++ b/paddle/fluid/operators/collective/c_reducescatter_op.cc @@ -60,17 +60,18 @@ Reference: https://docs.nvidia.com/deeplearning/sdk/nccl-developer-guide/docs/us } }; -class CReduceScatterOpGradMaker : public framework::SingleGradOpDescMaker { +template +class CReduceScatterOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr retv(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr retv(new T()); retv->SetType("c_allgather"); - retv->SetInput("X", OutputGrad("Out")); - retv->SetOutput("Out", InputGrad("X")); - retv->SetAttrMap(Attrs()); + retv->SetInput("X", this->OutputGrad("Out")); + retv->SetOutput("Out", this->InputGrad("X")); + retv->SetAttrMap(this->Attrs()); return retv; } }; diff --git a/paddle/fluid/operators/concat_op.cc b/paddle/fluid/operators/concat_op.cc index 820d3e3df700348bdac8368afd17d51e15e5bd92..ceb25fad2c2f48d3bfc8618d4f63332a1fcfc514 100644 --- a/paddle/fluid/operators/concat_op.cc +++ b/paddle/fluid/operators/concat_op.cc @@ -187,19 +187,20 @@ class ConcatOpGrad : public framework::OperatorWithKernel { DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(ConcatOpGradNoNeedBufferVarInference, "X"); -class ConcatGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class ConcatGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("concat_grad"); - op->SetInput("X", Input("X")); - op->SetInput("AxisTensor", Input("AxisTensor")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X", false)); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + 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()); return op; } }; @@ -209,7 +210,8 @@ class ConcatGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(concat, ops::ConcatOp, ops::ConcatOpMaker, - ops::ConcatGradOpDescMaker); + ops::ConcatGradOpMaker, + ops::ConcatGradOpMaker); REGISTER_OPERATOR(concat_grad, ops::ConcatOpGrad, ops::ConcatOpGradNoNeedBufferVarInference); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/controlflow/compare_op.cc b/paddle/fluid/operators/controlflow/compare_op.cc index 5d3f9b43f8c08d356319fa0b9ccaf808811d3d39..7b359ff0beb4ddeb2d8c650ed792adb675be9027 100644 --- a/paddle/fluid/operators/controlflow/compare_op.cc +++ b/paddle/fluid/operators/controlflow/compare_op.cc @@ -110,18 +110,19 @@ class CompareOp : public framework::OperatorWithKernel { } // namespace operators } // namespace paddle -#define REGISTER_COMPARE_OP(op_type, _equation) \ - struct _##op_type##Comment { \ - static char type[]; \ - static char equation[]; \ - }; \ - char _##op_type##Comment::type[]{#op_type}; \ - char _##op_type##Comment::equation[]{_equation}; \ - REGISTER_OPERATOR( \ - op_type, ::paddle::operators::CompareOp, \ - ::paddle::operators::CompareOpProtoMaker<_##op_type##Comment>, \ - ::paddle::operators::CompareOpInferShape<_##op_type##Comment>, \ - ::paddle::framework::EmptyGradOpMaker); +#define REGISTER_COMPARE_OP(op_type, _equation) \ + struct _##op_type##Comment { \ + static char type[]; \ + static char equation[]; \ + }; \ + char _##op_type##Comment::type[]{#op_type}; \ + char _##op_type##Comment::equation[]{_equation}; \ + REGISTER_OPERATOR( \ + op_type, ::paddle::operators::CompareOp, \ + ::paddle::operators::CompareOpProtoMaker<_##op_type##Comment>, \ + ::paddle::operators::CompareOpInferShape<_##op_type##Comment>, \ + ::paddle::framework::EmptyGradOpMaker, \ + ::paddle::framework::EmptyGradOpMaker); REGISTER_COMPARE_OP(less_than, "Out = X < Y"); REGISTER_COMPARE_KERNEL(less_than, CPU, paddle::operators::LessThanFunctor); diff --git a/paddle/fluid/operators/controlflow/conditional_block_infer_op.cc b/paddle/fluid/operators/controlflow/conditional_block_infer_op.cc index 8ad2f79389d9148119b3399789d6671624897cd9..78acd8beb3f97bc2db5bb1503f4791e0e3af6660 100644 --- a/paddle/fluid/operators/controlflow/conditional_block_infer_op.cc +++ b/paddle/fluid/operators/controlflow/conditional_block_infer_op.cc @@ -69,6 +69,8 @@ class ConditionalBlockInferOp : public ConditionalOp { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(conditional_block_infer, ops::ConditionalBlockInferOp, - ops::ConditionalBlockOpProtoMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + conditional_block_infer, ops::ConditionalBlockInferOp, + ops::ConditionalBlockOpProtoMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/controlflow/conditional_block_op.cc b/paddle/fluid/operators/controlflow/conditional_block_op.cc index 260b5672b4f06ab37b9ac0d7fe40e5fb69beb96f..d1751ba6fa2d70fac555eeaed9adc1aad8caccf6 100644 --- a/paddle/fluid/operators/controlflow/conditional_block_op.cc +++ b/paddle/fluid/operators/controlflow/conditional_block_op.cc @@ -168,28 +168,33 @@ class ConditionalBlockGradInferShape : public framework::InferShapeBase { } }; -class ConditionalBlockGradMaker : public framework::SingleGradOpDescMaker { +template +class ConditionalBlockGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto grad_op = new T(); grad_op->SetType("conditional_block_grad"); grad_op->SetInput(ConditionalOp::kCondition, - Input(ConditionalOp::kCondition)); - grad_op->SetInput(ConditionalOp::kInputs, Input(ConditionalOp::kInputs)); - grad_op->SetInput(ConditionalOp::kOutputs, Output(ConditionalOp::kOutputs)); + this->Input(ConditionalOp::kCondition)); + grad_op->SetInput(ConditionalOp::kInputs, + this->Input(ConditionalOp::kInputs)); + grad_op->SetInput(ConditionalOp::kOutputs, + this->Output(ConditionalOp::kOutputs)); grad_op->SetInput(framework::GradVarName(ConditionalOp::kOutputs), - OutputGrad(ConditionalOp::kOutputs)); - grad_op->SetInput(ConditionalOp::kScope, Output(ConditionalOp::kScope)); + this->OutputGrad(ConditionalOp::kOutputs)); + grad_op->SetInput(ConditionalOp::kScope, + this->Output(ConditionalOp::kScope)); grad_op->SetOutput(framework::GradVarName(ConditionalOp::kCondition), - InputGrad(ConditionalOp::kCondition, false)); + this->InputGrad(ConditionalOp::kCondition, false)); grad_op->SetOutput(framework::GradVarName(ConditionalOp::kInputs), - InputGrad(ConditionalOp::kInputs, false)); + this->InputGrad(ConditionalOp::kInputs, false)); grad_op->SetBlockAttr("sub_block", this->grad_block_[0]); - grad_op->SetAttr("is_scalar_condition", GetAttr("is_scalar_condition")); - return std::unique_ptr(grad_op); + grad_op->SetAttr("is_scalar_condition", + this->GetAttr("is_scalar_condition")); + return std::unique_ptr(grad_op); } }; @@ -199,6 +204,6 @@ class ConditionalBlockGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(conditional_block, ops::ConditionalBlockOp, ops::ConditionalBlockOpProtoMaker, - ops::ConditionalBlockGradMaker); + ops::ConditionalBlockGradMaker); REGISTER_OPERATOR(conditional_block_grad, ops::ConditionalBlockGradOp, ops::ConditionalBlockGradInferShape); diff --git a/paddle/fluid/operators/controlflow/feed_op.cc b/paddle/fluid/operators/controlflow/feed_op.cc index 0dfed7f5cc1e929c1fb566df1a7dfb4b2450323b..1e3af06cea2917e5a1fc184318b96b2349966a4a 100644 --- a/paddle/fluid/operators/controlflow/feed_op.cc +++ b/paddle/fluid/operators/controlflow/feed_op.cc @@ -81,6 +81,8 @@ It should not be configured by users directly. } // namespace operators } // namespace paddle -REGISTER_OPERATOR(feed, paddle::operators::FeedOp, - paddle::framework::EmptyGradOpMaker, - paddle::operators::FeedOpInfoMaker); +REGISTER_OPERATOR( + feed, paddle::operators::FeedOp, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::operators::FeedOpInfoMaker); diff --git a/paddle/fluid/operators/controlflow/fetch_op.cc b/paddle/fluid/operators/controlflow/fetch_op.cc index 39fdf07f051da85413f5f1470fb136ff7b063a8c..93b4b2d474eb4bfe08a7b44a2dca8578c2d1c8f8 100644 --- a/paddle/fluid/operators/controlflow/fetch_op.cc +++ b/paddle/fluid/operators/controlflow/fetch_op.cc @@ -94,6 +94,8 @@ It should not be configured by users directly. } // namespace operators } // namespace paddle -REGISTER_OPERATOR(fetch, paddle::operators::FetchOp, - paddle::framework::EmptyGradOpMaker, - paddle::operators::FetchOpInfoMaker); +REGISTER_OPERATOR( + fetch, paddle::operators::FetchOp, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::operators::FetchOpInfoMaker); diff --git a/paddle/fluid/operators/controlflow/get_places_op.cc b/paddle/fluid/operators/controlflow/get_places_op.cc index fa77f97419b6d605e478709e13413606ff124572..6bbe0cefbd6089feabd4797c554239c9cbe83fa8 100644 --- a/paddle/fluid/operators/controlflow/get_places_op.cc +++ b/paddle/fluid/operators/controlflow/get_places_op.cc @@ -111,6 +111,8 @@ class GetPlacesInferShape : public framework::InferShapeBase { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(get_places, ops::GetPlacesOp, ops::GetPlacesOpProtoMaker, - ops::GetPlacesInferVarType, ops::GetPlacesInferShape, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + get_places, ops::GetPlacesOp, ops::GetPlacesOpProtoMaker, + ops::GetPlacesInferVarType, ops::GetPlacesInferShape, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/controlflow/logical_op.cc b/paddle/fluid/operators/controlflow/logical_op.cc index f97b7f2dc9bb727947dc79ee9cfc26136bf99e1c..95c16ebc949751c4506c15643b4b9e2f7ae42275 100644 --- a/paddle/fluid/operators/controlflow/logical_op.cc +++ b/paddle/fluid/operators/controlflow/logical_op.cc @@ -124,7 +124,8 @@ class LogicalOp : public framework::OperatorWithKernel { op_type, ::paddle::operators::LogicalOp, \ ::paddle::operators::BinaryLogicalOpProtoMaker<_##op_type##Comment>, \ ::paddle::operators::BinaryLogicalOpInferShape<_##op_type##Comment>, \ - ::paddle::framework::EmptyGradOpMaker); + ::paddle::framework::EmptyGradOpMaker, \ + ::paddle::framework::EmptyGradOpMaker); #define REGISTER_UNARY_LOGICAL_OP(op_type, _equation) \ struct _##op_type##Comment { \ @@ -137,7 +138,8 @@ class LogicalOp : public framework::OperatorWithKernel { op_type, ::paddle::operators::LogicalOp, \ ::paddle::operators::UnaryLogicalOpProtoMaker<_##op_type##Comment>, \ ::paddle::operators::UnaryLogicalOpInferShape<_##op_type##Comment>, \ - ::paddle::framework::EmptyGradOpMaker); + ::paddle::framework::EmptyGradOpMaker, \ + ::paddle::framework::EmptyGradOpMaker); REGISTER_BINARY_LOGICAL_OP(logical_and, "$$Out = X \\&\\& Y$$"); REGISTER_BINARY_LOGICAL_KERNEL(logical_and, CPU, diff --git a/paddle/fluid/operators/controlflow/tensor_array_read_write_op.cc b/paddle/fluid/operators/controlflow/tensor_array_read_write_op.cc index 063f30d2de8871df38b4f542bab0362e84c27eba..1afc8f6d73f11746a324b1f73c3f90443b11f772 100644 --- a/paddle/fluid/operators/controlflow/tensor_array_read_write_op.cc +++ b/paddle/fluid/operators/controlflow/tensor_array_read_write_op.cc @@ -188,35 +188,37 @@ class ReadFromArrayInferShape : public WriteToArrayInferShape { } }; -class WriteToArrayGradMaker : public framework::SingleGradOpDescMaker { +template +class WriteToArrayGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("read_from_array"); - grad_op->SetInput("I", Input("I")); - grad_op->SetInput("X", OutputGrad("Out")); - grad_op->SetOutput("Out", InputGrad("X")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("I", this->Input("I")); + grad_op->SetInput("X", this->OutputGrad("Out")); + grad_op->SetOutput("Out", this->InputGrad("X")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; -class ReadFromArrayGradMaker : public framework::SingleGradOpDescMaker { +template +class ReadFromArrayGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("write_to_array"); - grad_op->SetInput("I", Input("I")); - grad_op->SetInput("X", OutputGrad("Out")); - grad_op->SetOutput("Out", InputGrad("X")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("I", this->Input("I")); + grad_op->SetInput("X", this->OutputGrad("Out")); + grad_op->SetOutput("Out", this->InputGrad("X")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -226,7 +228,10 @@ class ReadFromArrayGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(write_to_array, ops::WriteToArrayOp, ops::WriteToArrayInferShape, ops::WriteToArrayOpProtoMaker, - ops::WriteToArrayGradMaker, ops::WriteToArrayInferVarType); + ops::WriteToArrayGradMaker, + ops::WriteToArrayGradMaker, + ops::WriteToArrayInferVarType); REGISTER_OPERATOR(read_from_array, ops::ReadFromArrayOp, ops::ReadFromArrayInferShape, ops::ReadFromArrayProtoMaker, - ops::ReadFromArrayGradMaker); + ops::ReadFromArrayGradMaker, + ops::ReadFromArrayGradMaker); diff --git a/paddle/fluid/operators/controlflow/while_op.cc b/paddle/fluid/operators/controlflow/while_op.cc index 00870c691c26102d43e5473fd6aa58d053efe69b..0953256b971efa146e4c5f814f0e1bf71b1de917 100644 --- a/paddle/fluid/operators/controlflow/while_op.cc +++ b/paddle/fluid/operators/controlflow/while_op.cc @@ -320,17 +320,18 @@ class WhileGradOp : public framework::OperatorBase { } }; -class WhileGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class WhileGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *while_grad = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *while_grad = new T(); while_grad->SetType("while_grad"); - while_grad->SetInput(kX, Input(kX)); - while_grad->SetInput(kOutputs, Output(kOutputs)); - while_grad->SetInput(kStepScopes, Output(kStepScopes)); + while_grad->SetInput(kX, this->Input(kX)); + while_grad->SetInput(kOutputs, this->Output(kOutputs)); + while_grad->SetInput(kStepScopes, this->Output(kStepScopes)); auto *grad_block = this->grad_block_[0]; auto *fwd_block = grad_block->ForwardBlock(); @@ -344,7 +345,8 @@ class WhileGradOpDescMaker : public framework::SingleGradOpDescMaker { inner_op_outputs.insert(oname); } } - auto igs = InputGrad(kX, /*do not drop empty gradient*/ false); + auto igs = this->InputGrad(kX, /*do not drop empty gradient*/ false); + for (auto &each_ig : igs) { if (inner_op_outputs.find(each_ig) == inner_op_outputs.end()) { VLOG(8) << "Ignore " << each_ig; @@ -356,11 +358,11 @@ class WhileGradOpDescMaker : public framework::SingleGradOpDescMaker { // OG should be re-calculated by step blocks, since many outputs of while op // do not need to calculate gradients. std::unordered_set block_ins; - block_ins.reserve(Input(kX).size() + Output(kOutputs).size()); - for (auto &p : Input(kX)) { + block_ins.reserve(this->Input(kX).size() + this->Output(kOutputs).size()); + for (auto &p : this->Input(kX)) { block_ins.insert(p); } - for (auto &o : Output(kOutputs)) { + for (auto &o : this->Output(kOutputs)) { block_ins.insert(o); } std::unordered_set output_grads; @@ -398,7 +400,7 @@ class WhileGradOpDescMaker : public framework::SingleGradOpDescMaker { while_grad->SetAttr(kSkipEagerDeletionVars, std::vector()); - return std::unique_ptr(while_grad); + return std::unique_ptr(while_grad); } }; @@ -468,9 +470,9 @@ class WhileGradOpShapeInference : public framework::InferShapeBase { } // namespace operators } // namespace paddle -REGISTER_OPERATOR(while, paddle::operators::WhileOp, - paddle::operators::WhileOpMaker, - paddle::operators::WhileGradOpDescMaker); +REGISTER_OPERATOR( + while, paddle::operators::WhileOp, paddle::operators::WhileOpMaker, + paddle::operators::WhileGradOpMaker); REGISTER_OPERATOR(while_grad, paddle::operators::WhileGradOp, paddle::operators::WhileGradOpShapeInference, paddle::operators::WhileGradOpVarTypeInference); diff --git a/paddle/fluid/operators/conv_op.cc b/paddle/fluid/operators/conv_op.cc index cf720cc627c60cbb5b733dc1cb6ccf3b8a005690..c8e45f9ec4ee8378560ad5b93838476a68f8727a 100644 --- a/paddle/fluid/operators/conv_op.cc +++ b/paddle/fluid/operators/conv_op.cc @@ -548,48 +548,50 @@ framework::OpKernelType ConvOpGrad::GetExpectedKernelType( return type; } -class Conv2DGradMaker : public framework::SingleGradOpDescMaker { +template +class Conv2DGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType(this->ForwardOpType() + "_grad"); - op->SetInput("Input", Input("Input")); - op->SetInput("Filter", Input("Filter")); - op->SetInput("Bias", Input("Bias")); - op->SetInput(framework::GradVarName("Output"), OutputGrad("Output")); + op->SetInput("Input", this->Input("Input")); + op->SetInput("Filter", this->Input("Filter")); + op->SetInput("Bias", this->Input("Bias")); + op->SetInput(framework::GradVarName("Output"), this->OutputGrad("Output")); - op->SetOutput(framework::GradVarName("Input"), InputGrad("Input")); - op->SetOutput(framework::GradVarName("Filter"), InputGrad("Filter")); - op->SetOutput(framework::GradVarName("Bias"), InputGrad("Bias")); - op->SetAttrMap(Attrs()); + op->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input")); + op->SetOutput(framework::GradVarName("Filter"), this->InputGrad("Filter")); + op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); + op->SetAttrMap(this->Attrs()); - return std::unique_ptr(op); + return std::unique_ptr(op); } }; -class Conv3DGradMaker : public framework::SingleGradOpDescMaker { +template +class Conv3DGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType(this->ForwardOpType() + "_grad"); - op->SetInput("Input", Input("Input")); - op->SetInput("Filter", Input("Filter")); - op->SetInput(framework::GradVarName("Output"), OutputGrad("Output")); + op->SetInput("Input", this->Input("Input")); + op->SetInput("Filter", this->Input("Filter")); + op->SetInput(framework::GradVarName("Output"), this->OutputGrad("Output")); - op->SetOutput(framework::GradVarName("Input"), InputGrad("Input")); - op->SetOutput(framework::GradVarName("Filter"), InputGrad("Filter")); + op->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input")); + op->SetOutput(framework::GradVarName("Filter"), this->InputGrad("Filter")); - if (ForwardOp().Inputs().count("ResidualData") != 0) { - op->SetInput("ResidualData", Input("ResidualData")); + if (this->HasInput("ResidualData")) { + op->SetInput("ResidualData", this->Input("ResidualData")); } - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - return std::unique_ptr(op); + return std::unique_ptr(op); } }; @@ -597,37 +599,40 @@ class Conv3DGradMaker : public framework::SingleGradOpDescMaker { * Inputs: I, W, dO, ddI, ddW * Outputs: ddO, dW, dI */ -class Conv2DDoubleGradMaker : public framework::SingleGradOpDescMaker { +template +class Conv2DDoubleGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType(this->ForwardOpType() + "_grad"); // I, W, dO, ddI, ddW - op->SetInput("Input", Input("Input")); - op->SetInput("Filter", Input("Filter")); - op->SetInput("DOutput", Input(framework::GradVarName("Output"))); - op->SetInput("DDInput", OutputGrad(framework::GradVarName("Input"))); - op->SetInput("DDFilter", OutputGrad(framework::GradVarName("Filter"))); + op->SetInput("Input", this->Input("Input")); + op->SetInput("Filter", this->Input("Filter")); + op->SetInput("DOutput", this->Input(framework::GradVarName("Output"))); + op->SetInput("DDInput", this->OutputGrad(framework::GradVarName("Input"))); + op->SetInput("DDFilter", + this->OutputGrad(framework::GradVarName("Filter"))); // ddO, dI, dW // Unlike grad op, double grad op does not use name@GRAD@GRAD // as key of ops' inputs and outputs. - auto ddx = OutputGrad(framework::GradVarName("Input")); - auto ddw = OutputGrad(framework::GradVarName("Filter")); - std::vector empty_str = {}; + auto ddx = this->OutputGrad(framework::GradVarName("Input")); + auto ddw = this->OutputGrad(framework::GradVarName("Filter")); op->SetOutput("DDOutput", - (ddx.empty() && ddw.empty()) - ? empty_str - : InputGrad(framework::GradVarName("Output"))); - op->SetOutput("DFilter", ddx.empty() ? empty_str : InputGrad("Filter")); - op->SetOutput("DInput", ddw.empty() ? empty_str : InputGrad("Input")); + ddx.empty() + ? this->Empty() + : this->InputGrad(framework::GradVarName("Output"))); + op->SetOutput("DFilter", + ddx.empty() ? this->Empty() : this->InputGrad("Filter")); + op->SetOutput("DInput", + ddw.empty() ? this->Empty() : this->InputGrad("Input")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - return std::unique_ptr(op); + return std::unique_ptr(op); } }; @@ -635,34 +640,37 @@ class Conv2DDoubleGradMaker : public framework::SingleGradOpDescMaker { * Inputs: I, W, dO, ddI, ddW * Outputs: ddO, dW, dI */ -class Conv3DDoubleGradMaker : public framework::SingleGradOpDescMaker { +template +class Conv3DDoubleGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType(this->ForwardOpType() + "_grad"); // I, W, dO, ddI, ddW - op->SetInput("Input", Input("Input")); - op->SetInput("Filter", Input("Filter")); - op->SetInput("DOutput", Input(framework::GradVarName("Output"))); - op->SetInput("DDInput", OutputGrad(framework::GradVarName("Input"))); - op->SetInput("DDFilter", OutputGrad(framework::GradVarName("Filter"))); + op->SetInput("Input", this->Input("Input")); + op->SetInput("Filter", this->Input("Filter")); + op->SetInput("DOutput", this->Input(framework::GradVarName("Output"))); + op->SetInput("DDInput", this->OutputGrad(framework::GradVarName("Input"))); + op->SetInput("DDFilter", + this->OutputGrad(framework::GradVarName("Filter"))); - auto ddx = OutputGrad(framework::GradVarName("Input")); - auto ddw = OutputGrad(framework::GradVarName("Filter")); - std::vector empty_str = {}; + auto ddx = this->OutputGrad(framework::GradVarName("Input")); + auto ddw = this->OutputGrad(framework::GradVarName("Filter")); op->SetOutput("DDOutput", - (ddx.empty() && ddw.empty()) - ? empty_str - : InputGrad(framework::GradVarName("Output"))); - op->SetOutput("DFilter", ddx.empty() ? empty_str : InputGrad("Filter")); - op->SetOutput("DInput", ddw.empty() ? empty_str : InputGrad("Input")); + ddx.empty() + ? this->Empty() + : this->InputGrad(framework::GradVarName("Output"))); + op->SetOutput("DFilter", + ddx.empty() ? this->Empty() : this->InputGrad("Filter")); + op->SetOutput("DInput", + ddw.empty() ? this->Empty() : this->InputGrad("Input")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - return std::unique_ptr(op); + return std::unique_ptr(op); } }; @@ -734,18 +742,28 @@ framework::OpKernelType ConvOpDoubleGrad::GetExpectedKernelType( namespace ops = paddle::operators; REGISTER_OPERATOR(conv2d, ops::ConvOp, ops::Conv2DOpMaker, - ops::ConvOpInferVarType, ops::Conv2DGradMaker); -REGISTER_OPERATOR(conv2d_grad, ops::ConvOpGrad, ops::Conv2DDoubleGradMaker); + ops::ConvOpInferVarType, + ops::Conv2DGradMaker, + ops::Conv2DGradMaker); +REGISTER_OPERATOR(conv2d_grad, ops::ConvOpGrad, + ops::Conv2DDoubleGradMaker, + ops::Conv2DDoubleGradMaker); REGISTER_OPERATOR(conv2d_grad_grad, ops::ConvOpDoubleGrad); // depthwise convolution op REGISTER_OPERATOR(depthwise_conv2d, ops::ConvOp, ops::Conv2DOpMaker, - ops::ConvOpInferVarType, ops::Conv2DGradMaker); + ops::ConvOpInferVarType, + ops::Conv2DGradMaker, + ops::Conv2DGradMaker); REGISTER_OPERATOR(depthwise_conv2d_grad, ops::ConvOpGrad); REGISTER_OPERATOR(conv3d, ops::ConvOp, ops::Conv3DOpMaker, - ops::ConvOpInferVarType, ops::Conv3DGradMaker); -REGISTER_OPERATOR(conv3d_grad, ops::ConvOpGrad, ops::Conv3DDoubleGradMaker); + ops::ConvOpInferVarType, + ops::Conv3DGradMaker, + ops::Conv3DGradMaker); +REGISTER_OPERATOR(conv3d_grad, ops::ConvOpGrad, + ops::Conv3DDoubleGradMaker, + ops::Conv3DDoubleGradMaker); REGISTER_OPERATOR(conv3d_grad_grad, ops::ConvOpDoubleGrad); // depthwise conv kernel diff --git a/paddle/fluid/operators/conv_shift_op.cc b/paddle/fluid/operators/conv_shift_op.cc index ddbd6f395fe29ab6ae3fb6f71227f5027c87805f..6c161d92a0ba3b9e133e33976350567141f7599d 100644 --- a/paddle/fluid/operators/conv_shift_op.cc +++ b/paddle/fluid/operators/conv_shift_op.cc @@ -193,20 +193,21 @@ class ConvShiftGradKernel } }; -class ConvShiftGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class ConvShiftGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("conv_shift_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Y", Input("Y")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Y", this->Input("Y")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -216,7 +217,8 @@ class ConvShiftGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(conv_shift, ops::ConvShiftOp, ops::ConvShiftOpMaker, - ops::ConvShiftGradOpDescMaker); + ops::ConvShiftGradOpMaker, + ops::ConvShiftGradOpMaker); REGISTER_OPERATOR(conv_shift_grad, ops::ConvShiftGradOp); REGISTER_OP_CPU_KERNEL(conv_shift, ops::ConvShiftKernel); diff --git a/paddle/fluid/operators/conv_transpose_op.cc b/paddle/fluid/operators/conv_transpose_op.cc index 4ba330447e22d860b380579275d2ac1921e20629..aead007367efe07f51519d8fcc54e8872d6bd153 100644 --- a/paddle/fluid/operators/conv_transpose_op.cc +++ b/paddle/fluid/operators/conv_transpose_op.cc @@ -390,24 +390,25 @@ framework::OpKernelType ConvTransposeOpGrad::GetExpectedKernelType( layout_, library_); } -class ConvTransposeGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class ConvTransposeGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); - op->SetType(ForwardOp().Type() + "_grad"); - op->SetInput("Input", Input("Input")); - op->SetInput("Filter", Input("Filter")); - op->SetOutput(framework::GradVarName("Input"), InputGrad("Input")); - op->SetOutput(framework::GradVarName("Filter"), InputGrad("Filter")); - if (ForwardOp().Inputs().count("Bias") > 0) { - op->SetInput("Bias", Input("Bias")); - op->SetOutput(framework::GradVarName("Bias"), InputGrad("Bias")); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); + op->SetType(this->ForwardOpType() + "_grad"); + op->SetInput("Input", this->Input("Input")); + op->SetInput("Filter", this->Input("Filter")); + op->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input")); + op->SetOutput(framework::GradVarName("Filter"), this->InputGrad("Filter")); + if (this->HasInput("Bias")) { + op->SetInput("Bias", this->Input("Bias")); + op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); } - op->SetInput(framework::GradVarName("Output"), OutputGrad("Output")); - op->SetAttrMap(Attrs()); + op->SetInput(framework::GradVarName("Output"), this->OutputGrad("Output")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -420,7 +421,8 @@ namespace ops = paddle::operators; // conv2d_transpose REGISTER_OPERATOR(conv2d_transpose, ops::ConvTransposeOp, ops::Conv2DTransposeOpMaker, - ops::ConvTransposeGradOpDescMaker); + ops::ConvTransposeGradOpMaker, + ops::ConvTransposeGradOpMaker); REGISTER_OPERATOR(conv2d_transpose_grad, ops::ConvTransposeOpGrad); REGISTER_OP_CPU_KERNEL( @@ -436,7 +438,8 @@ REGISTER_OP_CPU_KERNEL( // conv3d_transpose REGISTER_OPERATOR(conv3d_transpose, ops::ConvTransposeOp, ops::Conv3DTransposeOpMaker, - ops::ConvTransposeGradOpDescMaker); + ops::ConvTransposeGradOpMaker, + ops::ConvTransposeGradOpMaker); REGISTER_OPERATOR(conv3d_transpose_grad, ops::ConvTransposeOpGrad); REGISTER_OP_CPU_KERNEL( @@ -452,7 +455,8 @@ REGISTER_OP_CPU_KERNEL( // depthwise conv2d_transpose REGISTER_OPERATOR(depthwise_conv2d_transpose, ops::ConvTransposeOp, ops::Conv2DTransposeOpMaker, - ops::ConvTransposeGradOpDescMaker); + ops::ConvTransposeGradOpMaker, + ops::ConvTransposeGradOpMaker); REGISTER_OPERATOR(depthwise_conv2d_transpose_grad, ops::ConvTransposeOpGrad); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/cos_sim_op.cc b/paddle/fluid/operators/cos_sim_op.cc index 289bb5d2dddef7a92f46ef8e3f9fb554ddfd9bca..aaabc59e25c4b65ed1d5341b98c6d946f0d788fb 100644 --- a/paddle/fluid/operators/cos_sim_op.cc +++ b/paddle/fluid/operators/cos_sim_op.cc @@ -169,8 +169,10 @@ class CosSimOpGrad : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(cos_sim, ops::CosSimOp, ops::CosSimOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + cos_sim, ops::CosSimOp, ops::CosSimOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(cos_sim_grad, ops::CosSimOpGrad); REGISTER_OP_CPU_KERNEL( cos_sim, ops::CosSimKernel); diff --git a/paddle/fluid/operators/crop_op.cc b/paddle/fluid/operators/crop_op.cc index f42463582f86475209352a558b13a960425f665e..6fa9f87346aaedda06a9f27bd345a3c53a9e6089 100644 --- a/paddle/fluid/operators/crop_op.cc +++ b/paddle/fluid/operators/crop_op.cc @@ -181,21 +181,22 @@ class CropOpGrad : public framework::OperatorWithKernel { } }; -class CropGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class CropGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("crop_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput("X", Input("X")); - if (ForwardOp().Inputs().count("Offsets") > 0) { - op->SetInput("Offsets", Input("Offsets")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput("X", this->Input("X")); + if (this->HasInput("Offsets")) { + op->SetInput("Offsets", this->Input("Offsets")); } - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -205,7 +206,8 @@ class CropGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(crop, ops::CropOp, ops::CropOpMaker, - ops::CropGradOpDescMaker); + ops::CropGradOpMaker, + ops::CropGradOpMaker); REGISTER_OPERATOR(crop_grad, ops::CropOpGrad); REGISTER_OP_CPU_KERNEL( crop, ops::CropKernel, diff --git a/paddle/fluid/operators/crop_tensor_op.cc b/paddle/fluid/operators/crop_tensor_op.cc index e4a314cea06b3e69113721586a5dc716d76cab3d..83047ac8850a9880839f47ef353c6667b926a27d 100644 --- a/paddle/fluid/operators/crop_tensor_op.cc +++ b/paddle/fluid/operators/crop_tensor_op.cc @@ -273,24 +273,25 @@ class CropTensorOpGrad : public framework::OperatorWithKernel { } }; -class CropTensorGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class CropTensorGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("crop_tensor_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput("X", Input("X")); - if (ForwardOp().Inputs().count("OffsetsTensor") > 0) { - op->SetInput("OffsetsTensor", Input("OffsetsTensor")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput("X", this->Input("X")); + if (this->HasInput("OffsetsTensor")) { + op->SetInput("OffsetsTensor", this->Input("OffsetsTensor")); } - if (ForwardOp().Inputs().count("Offsets") > 0) { - op->SetInput("Offsets", Input("Offsets")); + if (this->HasInput("Offsets")) { + op->SetInput("Offsets", this->Input("Offsets")); } - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -300,7 +301,8 @@ class CropTensorGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(crop_tensor, ops::CropTensorOp, ops::CropTensorOpMaker, - ops::CropTensorGradOpDescMaker); + ops::CropTensorGradOpMaker, + ops::CropTensorGradOpMaker); REGISTER_OPERATOR(crop_tensor_grad, ops::CropTensorOpGrad); REGISTER_OP_CPU_KERNEL( crop_tensor, diff --git a/paddle/fluid/operators/cross_entropy_op.cc b/paddle/fluid/operators/cross_entropy_op.cc index d6da40ddfe6fe2c262aeee8e2db1c0b5f9ecf83e..ab5d45b800de1f268165a5505c8b7f3e637ecd91 100644 --- a/paddle/fluid/operators/cross_entropy_op.cc +++ b/paddle/fluid/operators/cross_entropy_op.cc @@ -257,19 +257,20 @@ class CrossEntropyGradientOp : public CrossEntropyGradientOpBase { } }; -class CrossEntropyGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class CrossEntropyGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("cross_entropy_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Label", Input("Label")); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Label", this->Input("Label")); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -365,20 +366,21 @@ or not. But the output only shares the LoD information with input X. } }; -class CrossEntropyGradOpDescMaker2 : public framework::SingleGradOpDescMaker { +template +class CrossEntropyGradOpMaker2 : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("cross_entropy_grad2"); - op->SetInput("Label", Input("Label")); - op->SetInput("MatchX", Output("MatchX")); - op->SetInput("XShape", Output("XShape")); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("Label", this->Input("Label")); + op->SetInput("MatchX", this->Output("MatchX")); + op->SetInput("XShape", this->Output("XShape")); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -391,7 +393,8 @@ using CPUCtx = paddle::platform::CPUDeviceContext; REGISTER_OPERATOR(cross_entropy, ops::CrossEntropyOpBase, ops::CrossEntropyOpMaker, ops::CrossEntropyOpInferVarType, - ops::CrossEntropyGradOpDescMaker); + ops::CrossEntropyGradOpMaker, + ops::CrossEntropyGradOpMaker); REGISTER_OPERATOR(cross_entropy_grad, ops::CrossEntropyGradientOp); REGISTER_OP_CPU_KERNEL(cross_entropy, ops::CrossEntropyOpKernel, ops::CrossEntropyOpKernel); @@ -401,7 +404,8 @@ REGISTER_OP_CPU_KERNEL(cross_entropy_grad, REGISTER_OPERATOR(cross_entropy2, ops::CrossEntropyOp2, ops::CrossEntropyOpMaker2, ops::CrossEntropyOpInferVarType, - ops::CrossEntropyGradOpDescMaker2); + ops::CrossEntropyGradOpMaker2, + ops::CrossEntropyGradOpMaker2); REGISTER_OPERATOR(cross_entropy_grad2, ops::CrossEntropyGradientOp2); REGISTER_OP_CPU_KERNEL(cross_entropy2, ops::CrossEntropyOpKernel2, diff --git a/paddle/fluid/operators/ctc_align_op.cc b/paddle/fluid/operators/ctc_align_op.cc index 9982230495d7e96110876dce5a98ebf2ead5f133..be386a8eb8403394a05f59e50a30788575be1d88 100644 --- a/paddle/fluid/operators/ctc_align_op.cc +++ b/paddle/fluid/operators/ctc_align_op.cc @@ -125,8 +125,10 @@ Then: } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(ctc_align, ops::CTCAlignOp, ops::CTCAlignOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + ctc_align, ops::CTCAlignOp, ops::CTCAlignOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( ctc_align, ops::CTCAlignKernel, ops::CTCAlignKernel); diff --git a/paddle/fluid/operators/cudnn_lstm_op.cc b/paddle/fluid/operators/cudnn_lstm_op.cc index 73e04da3b0db275ed4d49878e8c0a8879b3106dd..ed1e06be7f98ce9c9f37f8625927c04453e5740c 100644 --- a/paddle/fluid/operators/cudnn_lstm_op.cc +++ b/paddle/fluid/operators/cudnn_lstm_op.cc @@ -197,31 +197,32 @@ class CudnnLSTMGradOp : public framework::OperatorWithKernel { } }; -class CudnnLSTMGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class CudnnLSTMGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("cudnn_lstm_grad"); - op->SetInput("Input", Input("Input")); - op->SetInput("InitH", Input("InitH")); - op->SetInput("InitC", Input("InitC")); - op->SetInput("W", Input("W")); - if (ForwardOp().Inputs().count("Cache") > 0) { - op->SetInput("Cache", Input("Cache")); + op->SetInput("Input", this->Input("Input")); + op->SetInput("InitH", this->Input("InitH")); + op->SetInput("InitC", this->Input("InitC")); + op->SetInput("W", this->Input("W")); + if (this->HasInput("Cache")) { + op->SetInput("Cache", this->Input("Cache")); } - op->SetInput("Out", Output("Out")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput(framework::GradVarName("last_c"), OutputGrad("last_c")); - op->SetInput(framework::GradVarName("last_h"), OutputGrad("last_h")); - - op->SetOutput(framework::GradVarName("Input"), InputGrad("Input")); - op->SetOutput(framework::GradVarName("W"), InputGrad("W")); - op->SetOutput(framework::GradVarName("InitH"), InputGrad("InitH")); - op->SetOutput(framework::GradVarName("InitC"), InputGrad("InitC")); - op->SetAttrMap(Attrs()); + op->SetInput("Out", this->Output("Out")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput(framework::GradVarName("last_c"), this->OutputGrad("last_c")); + op->SetInput(framework::GradVarName("last_h"), this->OutputGrad("last_h")); + + op->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input")); + op->SetOutput(framework::GradVarName("W"), this->InputGrad("W")); + op->SetOutput(framework::GradVarName("InitH"), this->InputGrad("InitH")); + op->SetOutput(framework::GradVarName("InitC"), this->InputGrad("InitC")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -240,7 +241,8 @@ class NotImpleKernel : public framework::OpKernel { namespace ops = paddle::operators; REGISTER_OPERATOR(cudnn_lstm, ops::CudnnLSTMOp, ops::CudnnLSTMOpMaker, - ops::CudnnLSTMGradOpDescMaker); + ops::CudnnLSTMGradOpMaker, + ops::CudnnLSTMGradOpMaker); REGISTER_OPERATOR(cudnn_lstm_grad, ops::CudnnLSTMGradOp); REGISTER_OP_CPU_KERNEL(cudnn_lstm, ops::NotImpleKernel); diff --git a/paddle/fluid/operators/cumsum_op.cc b/paddle/fluid/operators/cumsum_op.cc index 5302b822d6b9f232e9ccd0d03cc549d7d5044ebf..ab81a2873bf12455baa6ba222ff9aa50db0f9008 100644 --- a/paddle/fluid/operators/cumsum_op.cc +++ b/paddle/fluid/operators/cumsum_op.cc @@ -52,20 +52,21 @@ the input. If exlusive is true, the first element of the result is 0. } }; -class CumsumGradMaker : public framework::SingleGradOpDescMaker { +template +class CumsumGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("cumsum"); - grad_op->SetInput("X", OutputGrad("Out")); - grad_op->SetOutput("Out", InputGrad("X")); - grad_op->SetAttr("axis", Attr("axis")); - grad_op->SetAttr("reverse", !Attr("reverse")); - grad_op->SetAttr("exclusive", Attr("exclusive")); - return std::unique_ptr(grad_op); + grad_op->SetInput("X", this->OutputGrad("Out")); + grad_op->SetOutput("Out", this->InputGrad("X")); + grad_op->SetAttr("axis", boost::get(this->GetAttr("axis"))); + grad_op->SetAttr("reverse", !boost::get(this->GetAttr("reverse"))); + grad_op->SetAttr("exclusive", boost::get(this->GetAttr("exclusive"))); + return std::unique_ptr(grad_op); } }; @@ -75,7 +76,9 @@ class CumsumGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; using CPU = paddle::platform::CPUDeviceContext; -REGISTER_OPERATOR(cumsum, ops::CumOp, ops::CumsumOpMaker, ops::CumsumGradMaker); +REGISTER_OPERATOR(cumsum, ops::CumOp, ops::CumsumOpMaker, + ops::CumsumGradMaker, + ops::CumsumGradMaker); REGISTER_OP_CPU_KERNEL(cumsum, ops::CumKernel>, ops::CumKernel>, ops::CumKernel>); diff --git a/paddle/fluid/operators/cvm_op.cc b/paddle/fluid/operators/cvm_op.cc index 7675a6acf7e4458a23ad60faf3e5bcb2d158887e..327d75608ba5d9adf4df3d794bfa967c453a63a1 100644 --- a/paddle/fluid/operators/cvm_op.cc +++ b/paddle/fluid/operators/cvm_op.cc @@ -125,19 +125,20 @@ CVM Operator. } }; -class CVMGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class CVMGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("cvm_grad"); - op->SetInput("X", Input("X")); - op->SetInput("CVM", Input("CVM")); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("CVM", this->Input("CVM")); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -146,7 +147,9 @@ class CVMGradOpDescMaker : public framework::SingleGradOpDescMaker { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(cvm, ops::CVMOp, ops::CVMOpMaker, ops::CVMGradOpDescMaker); +REGISTER_OPERATOR(cvm, ops::CVMOp, ops::CVMOpMaker, + ops::CVMGradOpMaker, + ops::CVMGradOpMaker); REGISTER_OPERATOR(cvm_grad, ops::CVMGradientOp); diff --git a/paddle/fluid/operators/data_norm_op.cc b/paddle/fluid/operators/data_norm_op.cc index 6d1168c3ae80cce86ee801d9514b7bf5f2e7620c..dc116ec69a2ebd956b6828a8e97a3d960700bb95 100644 --- a/paddle/fluid/operators/data_norm_op.cc +++ b/paddle/fluid/operators/data_norm_op.cc @@ -375,32 +375,35 @@ class DataNormGradKernel } }; -class DataNormGradMaker : public framework::SingleGradOpDescMaker { +template +class DataNormGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *op = new T(); op->SetType("data_norm_grad"); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - - op->SetInput("BatchSize", Input("BatchSize")); - op->SetInput("BatchSum", Input("BatchSum")); - op->SetInput("BatchSquareSum", Input("BatchSquareSum")); - op->SetInput("Scales", Output("Scales")); - op->SetInput("Means", Output("Means")); - - op->SetAttrMap(Attrs()); - - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("BatchSize"), InputGrad("BatchSize")); - op->SetOutput(framework::GradVarName("BatchSum"), InputGrad("BatchSum")); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + + op->SetInput("BatchSize", this->Input("BatchSize")); + op->SetInput("BatchSum", this->Input("BatchSum")); + op->SetInput("BatchSquareSum", this->Input("BatchSquareSum")); + op->SetInput("Scales", this->Output("Scales")); + op->SetInput("Means", this->Output("Means")); + + op->SetAttrMap(this->Attrs()); + + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("BatchSize"), + this->InputGrad("BatchSize")); + op->SetOutput(framework::GradVarName("BatchSum"), + this->InputGrad("BatchSum")); op->SetOutput(framework::GradVarName("BatchSquareSum"), - InputGrad("BatchSquareSum")); + this->InputGrad("BatchSquareSum")); - return std::unique_ptr(op); + return std::unique_ptr(op); } }; @@ -409,7 +412,8 @@ class DataNormGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(data_norm, ops::DataNormOp, ops::DataNormOpMaker, - ops::DataNormGradMaker); + ops::DataNormGradMaker, + ops::DataNormGradMaker); REGISTER_OPERATOR(data_norm_grad, ops::DataNormGradOp); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/deformable_conv_op.cc b/paddle/fluid/operators/deformable_conv_op.cc index 1eedcc010f27a426b9b66fc897e22f679bd4acba..32951a447f68d9964a462fb2e70bbf3592caec3a 100644 --- a/paddle/fluid/operators/deformable_conv_op.cc +++ b/paddle/fluid/operators/deformable_conv_op.cc @@ -222,27 +222,28 @@ class DeformableConvOp : public framework::OperatorWithKernel { } }; -class DeformableConvGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class DeformableConvGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("deformable_conv_grad"); - op->SetInput("Input", Input("Input")); - op->SetInput("Filter", Input("Filter")); - op->SetInput("Offset", Input("Offset")); - op->SetInput("Mask", Input("Mask")); - op->SetInput(framework::GradVarName("Output"), OutputGrad("Output")); - - op->SetOutput(framework::GradVarName("Input"), InputGrad("Input")); - op->SetOutput(framework::GradVarName("Filter"), InputGrad("Filter")); - op->SetOutput(framework::GradVarName("Offset"), InputGrad("Offset")); - op->SetOutput(framework::GradVarName("Mask"), InputGrad("Mask")); - - op->SetAttrMap(Attrs()); + op->SetInput("Input", this->Input("Input")); + op->SetInput("Filter", this->Input("Filter")); + op->SetInput("Offset", this->Input("Offset")); + op->SetInput("Mask", this->Input("Mask")); + op->SetInput(framework::GradVarName("Output"), this->OutputGrad("Output")); + + op->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input")); + op->SetOutput(framework::GradVarName("Filter"), this->InputGrad("Filter")); + op->SetOutput(framework::GradVarName("Offset"), this->InputGrad("Offset")); + op->SetOutput(framework::GradVarName("Mask"), this->InputGrad("Mask")); + + op->SetAttrMap(this->Attrs()); return op; } }; @@ -287,7 +288,9 @@ class DeformableConvGradOp : public framework::OperatorWithKernel { namespace ops = paddle::operators; REGISTER_OPERATOR(deformable_conv, ops::DeformableConvOp, ops::DeformableConvOpMaker, - ops::DeformableConvGradOpDescMaker); + ops::DeformableConvGradOpMaker, + ops::DeformableConvGradOpMaker); + REGISTER_OPERATOR(deformable_conv_grad, ops::DeformableConvGradOp); REGISTER_OP_CPU_KERNEL(deformable_conv, ops::DeformableConvCPUKernel, diff --git a/paddle/fluid/operators/deformable_conv_v1_op.cc b/paddle/fluid/operators/deformable_conv_v1_op.cc index 8bef1a0b7486dff57c626963c2bc5d5ea3abf5b3..c76bb6c152c045f302fea4339fc3f53197bfe17e 100644 --- a/paddle/fluid/operators/deformable_conv_v1_op.cc +++ b/paddle/fluid/operators/deformable_conv_v1_op.cc @@ -205,26 +205,26 @@ class DeformableConvV1Op : public framework::OperatorWithKernel { } }; -class DeformableConvV1GradOpDescMaker - : public framework::SingleGradOpDescMaker { +template +class DeformableConvV1GradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("deformable_conv_v1_grad"); - op->SetInput("Input", Input("Input")); - op->SetInput("Filter", Input("Filter")); - op->SetInput("Offset", Input("Offset")); - op->SetInput(framework::GradVarName("Output"), OutputGrad("Output")); + op->SetInput("Input", this->Input("Input")); + op->SetInput("Filter", this->Input("Filter")); + op->SetInput("Offset", this->Input("Offset")); + op->SetInput(framework::GradVarName("Output"), this->OutputGrad("Output")); - op->SetOutput(framework::GradVarName("Input"), InputGrad("Input")); - op->SetOutput(framework::GradVarName("Filter"), InputGrad("Filter")); - op->SetOutput(framework::GradVarName("Offset"), InputGrad("Offset")); + op->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input")); + op->SetOutput(framework::GradVarName("Filter"), this->InputGrad("Filter")); + op->SetOutput(framework::GradVarName("Offset"), this->InputGrad("Offset")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -265,7 +265,8 @@ class DeformableConvV1GradOp : public framework::OperatorWithKernel { namespace ops = paddle::operators; REGISTER_OPERATOR(deformable_conv_v1, ops::DeformableConvV1Op, ops::DeformableConvV1OpMaker, - ops::DeformableConvV1GradOpDescMaker); + ops::DeformableConvV1GradOpMaker, + ops::DeformableConvV1GradOpMaker); REGISTER_OPERATOR(deformable_conv_v1_grad, ops::DeformableConvV1GradOp); REGISTER_OP_CPU_KERNEL(deformable_conv_v1, diff --git a/paddle/fluid/operators/deformable_psroi_pooling_op.cc b/paddle/fluid/operators/deformable_psroi_pooling_op.cc index dd2f700901b177083df8d1b3e5d34c46f82a9950..e76649e828369c66702d08aced51e7edf881579a 100644 --- a/paddle/fluid/operators/deformable_psroi_pooling_op.cc +++ b/paddle/fluid/operators/deformable_psroi_pooling_op.cc @@ -205,26 +205,26 @@ class DeformablePSROIPoolOp : public framework::OperatorWithKernel { } }; -class DeformablePSROIPoolGradOpDescMaker - : public framework::SingleGradOpDescMaker { +template +class DeformablePSROIPoolGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("deformable_psroi_pooling_grad"); - op->SetInput("Input", Input("Input")); - op->SetInput("Trans", Input("Trans")); - op->SetInput("ROIs", Input("ROIs")); - op->SetInput("TopCount", Output("TopCount")); - op->SetInput(framework::GradVarName("Output"), OutputGrad("Output")); + op->SetInput("Input", this->Input("Input")); + op->SetInput("Trans", this->Input("Trans")); + op->SetInput("ROIs", this->Input("ROIs")); + op->SetInput("TopCount", this->Output("TopCount")); + op->SetInput(framework::GradVarName("Output"), this->OutputGrad("Output")); - op->SetOutput(framework::GradVarName("Input"), InputGrad("Input")); - op->SetOutput(framework::GradVarName("Trans"), InputGrad("Trans")); + op->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input")); + op->SetOutput(framework::GradVarName("Trans"), this->InputGrad("Trans")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -259,9 +259,11 @@ class DeformablePSROIPoolGradOp : public framework::OperatorWithKernel { namespace ops = paddle::operators; using CPU = paddle::platform::CPUDeviceContext; -REGISTER_OPERATOR(deformable_psroi_pooling, ops::DeformablePSROIPoolOp, - ops::DeformablePSROIPoolOpMaker, - ops::DeformablePSROIPoolGradOpDescMaker); +REGISTER_OPERATOR( + deformable_psroi_pooling, ops::DeformablePSROIPoolOp, + ops::DeformablePSROIPoolOpMaker, + ops::DeformablePSROIPoolGradOpMaker, + ops::DeformablePSROIPoolGradOpMaker); REGISTER_OPERATOR(deformable_psroi_pooling_grad, ops::DeformablePSROIPoolGradOp); REGISTER_OP_CPU_KERNEL(deformable_psroi_pooling, diff --git a/paddle/fluid/operators/delete_var_op.cc b/paddle/fluid/operators/delete_var_op.cc index 89416f7ab5d07ddac5b540b9bb361f831c1ef360..ec60569be200a4ed09aff046233f9977f47b5195 100644 --- a/paddle/fluid/operators/delete_var_op.cc +++ b/paddle/fluid/operators/delete_var_op.cc @@ -51,7 +51,9 @@ It should not be configured by users directly. } // namespace operators } // namespace paddle -REGISTER_OPERATOR(delete_var, paddle::operators::DeleteVarOp, - paddle::framework::EmptyGradOpMaker, - paddle::operators::DeleteVarOpInfoMaker, - paddle::operators::DeleteVarOpShapeInference); +REGISTER_OPERATOR( + delete_var, paddle::operators::DeleteVarOp, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::operators::DeleteVarOpInfoMaker, + paddle::operators::DeleteVarOpShapeInference); diff --git a/paddle/fluid/operators/detection/anchor_generator_op.cc b/paddle/fluid/operators/detection/anchor_generator_op.cc index d3287249166833f50fd4182c9cfcba6c03906652..a3030dbdd246f5252e1fca97afb9089ef0c2c016 100644 --- a/paddle/fluid/operators/detection/anchor_generator_op.cc +++ b/paddle/fluid/operators/detection/anchor_generator_op.cc @@ -146,9 +146,10 @@ https://arxiv.org/abs/1506.01497. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(anchor_generator, ops::AnchorGeneratorOp, - ops::AnchorGeneratorOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + anchor_generator, ops::AnchorGeneratorOp, ops::AnchorGeneratorOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(anchor_generator, ops::AnchorGeneratorOpKernel, ops::AnchorGeneratorOpKernel); diff --git a/paddle/fluid/operators/detection/bipartite_match_op.cc b/paddle/fluid/operators/detection/bipartite_match_op.cc index 785a207263191e516c47da76ecb6ce771f0242f2..de4579919c38c166c27163dff6017c1ebea4bfd2 100644 --- a/paddle/fluid/operators/detection/bipartite_match_op.cc +++ b/paddle/fluid/operators/detection/bipartite_match_op.cc @@ -284,8 +284,9 @@ If Tensor, the height of ColToRowMatchIndices is 1. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(bipartite_match, ops::BipartiteMatchOp, - ops::BipartiteMatchOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + bipartite_match, ops::BipartiteMatchOp, ops::BipartiteMatchOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(bipartite_match, ops::BipartiteMatchKernel, ops::BipartiteMatchKernel); diff --git a/paddle/fluid/operators/detection/box_clip_op.cc b/paddle/fluid/operators/detection/box_clip_op.cc index 3aa766559a530bc31fbb277f2bcd474da776e63b..9e4c7f1619a27edf933869dbbde1edd0f9c54ae1 100644 --- a/paddle/fluid/operators/detection/box_clip_op.cc +++ b/paddle/fluid/operators/detection/box_clip_op.cc @@ -79,8 +79,10 @@ where im_w and im_h are computed from ImInfo, the formula is given as follows: } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(box_clip, ops::BoxClipOp, ops::BoxClipOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + box_clip, ops::BoxClipOp, ops::BoxClipOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( box_clip, ops::BoxClipKernel, ops::BoxClipKernel); diff --git a/paddle/fluid/operators/detection/box_coder_op.cc b/paddle/fluid/operators/detection/box_coder_op.cc index de3612677440596387f313e1ff59184cb3fdb7ae..070c822a7edbe346000e6f5f9b76f67686114b59 100644 --- a/paddle/fluid/operators/detection/box_coder_op.cc +++ b/paddle/fluid/operators/detection/box_coder_op.cc @@ -185,8 +185,10 @@ box will broadcast to target box along the assigned axis. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(box_coder, ops::BoxCoderOp, ops::BoxCoderOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + box_coder, ops::BoxCoderOp, ops::BoxCoderOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( box_coder, ops::BoxCoderKernel, ops::BoxCoderKernel); diff --git a/paddle/fluid/operators/detection/box_decoder_and_assign_op.cc b/paddle/fluid/operators/detection/box_decoder_and_assign_op.cc index 976aa317b8819b46fe3dd06c68d384fa6e34c6fd..95670a0d0a1ff63e01de048ba5d1998a93bb4c38 100644 --- a/paddle/fluid/operators/detection/box_decoder_and_assign_op.cc +++ b/paddle/fluid/operators/detection/box_decoder_and_assign_op.cc @@ -162,9 +162,11 @@ output_assign_box is the same as PriorBox. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(box_decoder_and_assign, ops::BoxDecoderAndAssignOp, - ops::BoxDecoderAndAssignOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + box_decoder_and_assign, ops::BoxDecoderAndAssignOp, + ops::BoxDecoderAndAssignOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( box_decoder_and_assign, ops::BoxDecoderAndAssignKernel, diff --git a/paddle/fluid/operators/detection/collect_fpn_proposals_op.cc b/paddle/fluid/operators/detection/collect_fpn_proposals_op.cc index 8c53eb5da2f69f7a516ad98c9cee182ec232bab8..b314275174ad0f232ca71561cf8d5717995079fa 100644 --- a/paddle/fluid/operators/detection/collect_fpn_proposals_op.cc +++ b/paddle/fluid/operators/detection/collect_fpn_proposals_op.cc @@ -100,9 +100,11 @@ by objectness confidence. Select the post_nms_topN RoIs in } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(collect_fpn_proposals, ops::CollectFpnProposalsOp, - ops::CollectFpnProposalsOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + collect_fpn_proposals, ops::CollectFpnProposalsOp, + ops::CollectFpnProposalsOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(collect_fpn_proposals, ops::CollectFpnProposalsOpKernel, ops::CollectFpnProposalsOpKernel); diff --git a/paddle/fluid/operators/detection/density_prior_box_op.cc b/paddle/fluid/operators/detection/density_prior_box_op.cc index f9ea1dc67d9dcdfb8de7e91bc348e50f5d03e319..cfa5f467f0d63fa5e4299c529d8ca6ae86332680 100644 --- a/paddle/fluid/operators/detection/density_prior_box_op.cc +++ b/paddle/fluid/operators/detection/density_prior_box_op.cc @@ -172,9 +172,10 @@ class DensityPriorBoxOpMaker : public framework::OpProtoAndCheckerMaker { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(density_prior_box, ops::DensityPriorBoxOp, - ops::DensityPriorBoxOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + density_prior_box, ops::DensityPriorBoxOp, ops::DensityPriorBoxOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(density_prior_box, ops::DensityPriorBoxOpKernel, ops::DensityPriorBoxOpKernel); diff --git a/paddle/fluid/operators/detection/distribute_fpn_proposals_op.cc b/paddle/fluid/operators/detection/distribute_fpn_proposals_op.cc index ce37e73b750d669190615d01697d77039bf857c3..2976c3ff4c86f0fef6127d5a02967db6be032b26 100644 --- a/paddle/fluid/operators/detection/distribute_fpn_proposals_op.cc +++ b/paddle/fluid/operators/detection/distribute_fpn_proposals_op.cc @@ -85,9 +85,11 @@ we return an array which indicate the original index of rois in } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(distribute_fpn_proposals, ops::DistributeFpnProposalsOp, - ops::DistributeFpnProposalsOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + distribute_fpn_proposals, ops::DistributeFpnProposalsOp, + ops::DistributeFpnProposalsOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(distribute_fpn_proposals, ops::DistributeFpnProposalsOpKernel, ops::DistributeFpnProposalsOpKernel); diff --git a/paddle/fluid/operators/detection/generate_mask_labels_op.cc b/paddle/fluid/operators/detection/generate_mask_labels_op.cc index bd18d77174f881b5773f775054091489fbdb2363..db69cf0301c2eb940418a74f1332a35457e560fd 100644 --- a/paddle/fluid/operators/detection/generate_mask_labels_op.cc +++ b/paddle/fluid/operators/detection/generate_mask_labels_op.cc @@ -434,8 +434,10 @@ K classes. This mask targets are used to compute loss of mask branch. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(generate_mask_labels, ops::GenerateMaskLabelsOp, - ops::GenerateMaskLabelsOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + generate_mask_labels, ops::GenerateMaskLabelsOp, + ops::GenerateMaskLabelsOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(generate_mask_labels, ops::GenerateMaskLabelsKernel); diff --git a/paddle/fluid/operators/detection/generate_proposal_labels_op.cc b/paddle/fluid/operators/detection/generate_proposal_labels_op.cc index 873d44b27e245ae7f12a5601903b462b568e3bc9..668459f0a3d136631aaf22af22b45da6cd8521cd 100644 --- a/paddle/fluid/operators/detection/generate_proposal_labels_op.cc +++ b/paddle/fluid/operators/detection/generate_proposal_labels_op.cc @@ -583,9 +583,11 @@ Finally BboxInsideWeights and BboxOutsideWeights are used to specify whether it } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(generate_proposal_labels, ops::GenerateProposalLabelsOp, - ops::GenerateProposalLabelsOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + generate_proposal_labels, ops::GenerateProposalLabelsOp, + ops::GenerateProposalLabelsOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(generate_proposal_labels, ops::GenerateProposalLabelsKernel, ops::GenerateProposalLabelsKernel); diff --git a/paddle/fluid/operators/detection/generate_proposals_op.cc b/paddle/fluid/operators/detection/generate_proposals_op.cc index bcbd7e1e2031ff1db0f1f0fabb3be2c339b62e19..1a9b62f4f6afd2e108e4c8927d5817d451eccc11 100644 --- a/paddle/fluid/operators/detection/generate_proposals_op.cc +++ b/paddle/fluid/operators/detection/generate_proposals_op.cc @@ -494,8 +494,9 @@ boxes. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(generate_proposals, ops::GenerateProposalsOp, - ops::GenerateProposalsOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + generate_proposals, ops::GenerateProposalsOp, ops::GenerateProposalsOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(generate_proposals, ops::GenerateProposalsKernel, ops::GenerateProposalsKernel); diff --git a/paddle/fluid/operators/detection/iou_similarity_op.cc b/paddle/fluid/operators/detection/iou_similarity_op.cc index 9c89b7ca9af1b235659554afc805600d31ef8ea6..b56c678099e2519ceb0ed69b6490211d1e86dc95 100644 --- a/paddle/fluid/operators/detection/iou_similarity_op.cc +++ b/paddle/fluid/operators/detection/iou_similarity_op.cc @@ -87,9 +87,10 @@ $$ } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(iou_similarity, ops::IOUSimilarityOp, - ops::IOUSimilarityOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + iou_similarity, ops::IOUSimilarityOp, ops::IOUSimilarityOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( iou_similarity, diff --git a/paddle/fluid/operators/detection/mine_hard_examples_op.cc b/paddle/fluid/operators/detection/mine_hard_examples_op.cc index c8701d28101f5f70691258d15e33a6b5bb7c44ae..24d59c94cb447c23374f4a1115026d852de50d0b 100644 --- a/paddle/fluid/operators/detection/mine_hard_examples_op.cc +++ b/paddle/fluid/operators/detection/mine_hard_examples_op.cc @@ -332,9 +332,10 @@ MatchIndices elements with value -1. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(mine_hard_examples, ops::MineHardExamplesOp, - ops::MineHardExamplesOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + mine_hard_examples, ops::MineHardExamplesOp, ops::MineHardExamplesOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( mine_hard_examples, diff --git a/paddle/fluid/operators/detection/multiclass_nms_op.cc b/paddle/fluid/operators/detection/multiclass_nms_op.cc index 28380a04ba194b8735f01d1dc19c0997405a027c..eb9a3c704833abdf5327815b5f15d13bbb8a2a8f 100644 --- a/paddle/fluid/operators/detection/multiclass_nms_op.cc +++ b/paddle/fluid/operators/detection/multiclass_nms_op.cc @@ -590,13 +590,15 @@ class MultiClassNMS2OpMaker : public MultiClassNMSOpMaker { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(multiclass_nms, ops::MultiClassNMSOp, - ops::MultiClassNMSOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + multiclass_nms, ops::MultiClassNMSOp, ops::MultiClassNMSOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(multiclass_nms, ops::MultiClassNMSKernel, ops::MultiClassNMSKernel); -REGISTER_OPERATOR(multiclass_nms2, ops::MultiClassNMS2Op, - ops::MultiClassNMS2OpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + multiclass_nms2, ops::MultiClassNMS2Op, ops::MultiClassNMS2OpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(multiclass_nms2, ops::MultiClassNMSKernel, ops::MultiClassNMSKernel); diff --git a/paddle/fluid/operators/detection/polygon_box_transform_op.cc b/paddle/fluid/operators/detection/polygon_box_transform_op.cc index 4b3bc2edb58fe23393d906094c41b6ad62c71155..ab134e2091723f792a98261608fe6c9a61c70cda 100644 --- a/paddle/fluid/operators/detection/polygon_box_transform_op.cc +++ b/paddle/fluid/operators/detection/polygon_box_transform_op.cc @@ -98,9 +98,11 @@ the geometry output contains 2*n channels. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(polygon_box_transform, ops::PolygonBoxTransformOp, - ops::PolygonBoxTransformOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + polygon_box_transform, ops::PolygonBoxTransformOp, + ops::PolygonBoxTransformOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( polygon_box_transform, ops::PolygonBoxTransformCPUKernel, diff --git a/paddle/fluid/operators/detection/prior_box_op.cc b/paddle/fluid/operators/detection/prior_box_op.cc index 8d821739f6f1a05cda966cb1ab1064194b5953dd..f4f3bcd667ad4d61228cc6481b40b51bf24faf18 100644 --- a/paddle/fluid/operators/detection/prior_box_op.cc +++ b/paddle/fluid/operators/detection/prior_box_op.cc @@ -203,8 +203,10 @@ https://arxiv.org/abs/1512.02325. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(prior_box, ops::PriorBoxOp, ops::PriorBoxOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + prior_box, ops::PriorBoxOp, ops::PriorBoxOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(prior_box, ops::PriorBoxOpKernel, ops::PriorBoxOpKernel); diff --git a/paddle/fluid/operators/detection/retinanet_detection_output_op.cc b/paddle/fluid/operators/detection/retinanet_detection_output_op.cc index a79a7608ea9c565b4c59cc6e4dfb11fca2f5be2c..a78a46c3499663c06010e3e88f627a96974b57da 100644 --- a/paddle/fluid/operators/detection/retinanet_detection_output_op.cc +++ b/paddle/fluid/operators/detection/retinanet_detection_output_op.cc @@ -557,9 +557,11 @@ empty (None). } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(retinanet_detection_output, ops::RetinanetDetectionOutputOp, - ops::RetinanetDetectionOutputOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + retinanet_detection_output, ops::RetinanetDetectionOutputOp, + ops::RetinanetDetectionOutputOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(retinanet_detection_output, ops::RetinanetDetectionOutputKernel, ops::RetinanetDetectionOutputKernel); diff --git a/paddle/fluid/operators/detection/roi_perspective_transform_op.cc b/paddle/fluid/operators/detection/roi_perspective_transform_op.cc index 20f0012276a9f6df320ed33005f3d486e2cfcc65..b220ea540a899e03ed58822c6c23efbbb9d3b9a5 100644 --- a/paddle/fluid/operators/detection/roi_perspective_transform_op.cc +++ b/paddle/fluid/operators/detection/roi_perspective_transform_op.cc @@ -620,22 +620,23 @@ class ROIPerspectiveTransformOpMaker } }; -class ROIPerspectiveTransformGradDescMaker - : public framework::SingleGradOpDescMaker { +template +class ROIPerspectiveTransformGradMaker + : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("roi_perspective_transform_grad"); - op->SetInput("X", Input("X")); - op->SetInput("ROIs", Input("ROIs")); - op->SetInput("Out2InIdx", Output("Out2InIdx")); - op->SetInput("Out2InWeights", Output("Out2InWeights")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("ROIs", this->Input("ROIs")); + op->SetInput("Out2InIdx", this->Output("Out2InIdx")); + op->SetInput("Out2InWeights", this->Output("Out2InWeights")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -644,9 +645,11 @@ class ROIPerspectiveTransformGradDescMaker } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(roi_perspective_transform, ops::ROIPerspectiveTransformOp, - ops::ROIPerspectiveTransformOpMaker, - ops::ROIPerspectiveTransformGradDescMaker); +REGISTER_OPERATOR( + roi_perspective_transform, ops::ROIPerspectiveTransformOp, + ops::ROIPerspectiveTransformOpMaker, + ops::ROIPerspectiveTransformGradMaker, + ops::ROIPerspectiveTransformGradMaker); REGISTER_OPERATOR(roi_perspective_transform_grad, ops::ROIPerspectiveTransformGradOp); REGISTER_OP_CPU_KERNEL(roi_perspective_transform, diff --git a/paddle/fluid/operators/detection/rpn_target_assign_op.cc b/paddle/fluid/operators/detection/rpn_target_assign_op.cc index 67aab192fbedcf74bbbd9194ffc4875493785979..374d73839ad8dba58afa372ac45a5155ab5b47fa 100644 --- a/paddle/fluid/operators/detection/rpn_target_assign_op.cc +++ b/paddle/fluid/operators/detection/rpn_target_assign_op.cc @@ -1022,14 +1022,17 @@ class RetinanetTargetAssignKernel : public framework::OpKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(rpn_target_assign, ops::RpnTargetAssignOp, - ops::RpnTargetAssignOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + rpn_target_assign, ops::RpnTargetAssignOp, ops::RpnTargetAssignOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(rpn_target_assign, ops::RpnTargetAssignKernel, ops::RpnTargetAssignKernel); -REGISTER_OPERATOR(retinanet_target_assign, ops::RetinanetTargetAssignOp, - ops::RetinanetTargetAssignOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + retinanet_target_assign, ops::RetinanetTargetAssignOp, + ops::RetinanetTargetAssignOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(retinanet_target_assign, ops::RetinanetTargetAssignKernel, ops::RetinanetTargetAssignKernel); diff --git a/paddle/fluid/operators/detection/sigmoid_focal_loss_op.cc b/paddle/fluid/operators/detection/sigmoid_focal_loss_op.cc index eb59c943e4bd4f63442191a900b6d03a6594d118..faa1258b9f5ccbde6a4847ee2a5f3bba96bbb081 100644 --- a/paddle/fluid/operators/detection/sigmoid_focal_loss_op.cc +++ b/paddle/fluid/operators/detection/sigmoid_focal_loss_op.cc @@ -172,21 +172,21 @@ We know that $$\sigma(X_j) = \\frac{1}{1 + \exp(-X_j)}$$. } }; -class SigmoidFocalLossGradOpDescMaker - : public framework::SingleGradOpDescMaker { +template +class SigmoidFocalLossGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("sigmoid_focal_loss_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Label", Input("Label")); - op->SetInput("FgNum", Input("FgNum")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Label", this->Input("Label")); + op->SetInput("FgNum", this->Input("FgNum")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -197,7 +197,8 @@ class SigmoidFocalLossGradOpDescMaker namespace ops = paddle::operators; REGISTER_OPERATOR(sigmoid_focal_loss, ops::SigmoidFocalLossOp, ops::SigmoidFocalLossOpMaker, - ops::SigmoidFocalLossGradOpDescMaker); + ops::SigmoidFocalLossGradOpMaker, + ops::SigmoidFocalLossGradOpMaker); REGISTER_OPERATOR(sigmoid_focal_loss_grad, ops::SigmoidFocalLossGradOp); REGISTER_OP_CPU_KERNEL( sigmoid_focal_loss, diff --git a/paddle/fluid/operators/detection/target_assign_op.cc b/paddle/fluid/operators/detection/target_assign_op.cc index b2487b13523a467a36e9663bf424c1e81ebc6e4f..7c187066c666f45ec5954d25280f716e32aa964b 100644 --- a/paddle/fluid/operators/detection/target_assign_op.cc +++ b/paddle/fluid/operators/detection/target_assign_op.cc @@ -152,8 +152,10 @@ template struct NegTargetAssignFunctor, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( target_assign, ops::TargetAssignKernel, diff --git a/paddle/fluid/operators/detection/yolo_box_op.cc b/paddle/fluid/operators/detection/yolo_box_op.cc index 602efd7b80ab137f308a1902f578f10dbe047c93..36218e7a0da5c72183627bc08d923fd633dbb614 100644 --- a/paddle/fluid/operators/detection/yolo_box_op.cc +++ b/paddle/fluid/operators/detection/yolo_box_op.cc @@ -161,7 +161,9 @@ class YoloBoxOpMaker : public framework::OpProtoAndCheckerMaker { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(yolo_box, ops::YoloBoxOp, ops::YoloBoxOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + yolo_box, ops::YoloBoxOp, ops::YoloBoxOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(yolo_box, ops::YoloBoxKernel, ops::YoloBoxKernel); diff --git a/paddle/fluid/operators/detection/yolov3_loss_op.cc b/paddle/fluid/operators/detection/yolov3_loss_op.cc index d6cd3171ee359fb7994cd1a60e2ca50c22b03c06..5ffcfc0458f30dea2987b3b6ee27a1aa91486e21 100644 --- a/paddle/fluid/operators/detection/yolov3_loss_op.cc +++ b/paddle/fluid/operators/detection/yolov3_loss_op.cc @@ -12,6 +12,7 @@ #include "paddle/fluid/operators/detection/yolov3_loss_op.h" #include #include "paddle/fluid/framework/op_registry.h" +#include "paddle/fluid/imperative/type_defs.h" namespace paddle { namespace operators { @@ -262,29 +263,30 @@ class Yolov3LossOpGrad : public framework::OperatorWithKernel { } }; -class Yolov3LossGradMaker : public framework::SingleGradOpDescMaker { +template +class Yolov3LossGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("yolov3_loss_grad"); - op->SetInput("X", Input("X")); - op->SetInput("GTBox", Input("GTBox")); - op->SetInput("GTLabel", Input("GTLabel")); - op->SetInput("GTScore", Input("GTScore")); - op->SetInput(framework::GradVarName("Loss"), OutputGrad("Loss")); - op->SetInput("ObjectnessMask", Output("ObjectnessMask")); - op->SetInput("GTMatchMask", Output("GTMatchMask")); + op->SetInput("X", this->Input("X")); + op->SetInput("GTBox", this->Input("GTBox")); + op->SetInput("GTLabel", this->Input("GTLabel")); + op->SetInput("GTScore", this->Input("GTScore")); + op->SetInput(framework::GradVarName("Loss"), this->OutputGrad("Loss")); + op->SetInput("ObjectnessMask", this->Output("ObjectnessMask")); + op->SetInput("GTMatchMask", this->Output("GTMatchMask")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); op->SetOutput(framework::GradVarName("GTBox"), {}); op->SetOutput(framework::GradVarName("GTLabel"), {}); op->SetOutput(framework::GradVarName("GTScore"), {}); - return std::unique_ptr(op); + return std::unique_ptr(op); } }; @@ -293,7 +295,8 @@ class Yolov3LossGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(yolov3_loss, ops::Yolov3LossOp, ops::Yolov3LossOpMaker, - ops::Yolov3LossGradMaker); + ops::Yolov3LossGradMaker, + ops::Yolov3LossGradMaker); REGISTER_OPERATOR(yolov3_loss_grad, ops::Yolov3LossOpGrad); REGISTER_OP_CPU_KERNEL(yolov3_loss, ops::Yolov3LossKernel, ops::Yolov3LossKernel); diff --git a/paddle/fluid/operators/detection_map_op.cc b/paddle/fluid/operators/detection_map_op.cc index cfd159a2cca529a7d82dfecd095bb420570c4a18..617edd781db9b056760566f87512a363668b3972 100644 --- a/paddle/fluid/operators/detection_map_op.cc +++ b/paddle/fluid/operators/detection_map_op.cc @@ -191,8 +191,10 @@ https://arxiv.org/abs/1512.02325 } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(detection_map, ops::DetectionMAPOp, ops::DetectionMAPOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + detection_map, ops::DetectionMAPOp, ops::DetectionMAPOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( detection_map, ops::DetectionMAPOpKernel, ops::DetectionMAPOpKernel); diff --git a/paddle/fluid/operators/diag_op.cc b/paddle/fluid/operators/diag_op.cc index 5fb18a1d695381d14203b19653eb3cbc2508ee4d..1a3dd006c7e6388277d74d21313f085a10b23019 100644 --- a/paddle/fluid/operators/diag_op.cc +++ b/paddle/fluid/operators/diag_op.cc @@ -51,8 +51,10 @@ class DiagOpMaker : public framework::OpProtoAndCheckerMaker { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(diag, ops::DiagOp, ops::DiagOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + diag, ops::DiagOp, ops::DiagOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( diag, ops::DiagKernel, ops::DiagKernel, diff --git a/paddle/fluid/operators/distributed_ops/checkpoint_notify_op.cc b/paddle/fluid/operators/distributed_ops/checkpoint_notify_op.cc index a09bff351fc0c7ae3858358701bf309e9d2f592a..cd7e4363fa0f3e7e5e4936b8a0d42cd8ec5352da 100644 --- a/paddle/fluid/operators/distributed_ops/checkpoint_notify_op.cc +++ b/paddle/fluid/operators/distributed_ops/checkpoint_notify_op.cc @@ -84,7 +84,8 @@ class CheckpointNotifyOpShapeInference : public framework::InferShapeBase { namespace ops = paddle::operators; -REGISTER_OPERATOR(checkpoint_notify, ops::CheckpointNotifyOp, - paddle::framework::EmptyGradOpMaker, - ops::CheckpointNotifyOpMaker, - ops::CheckpointNotifyOpShapeInference); +REGISTER_OPERATOR( + checkpoint_notify, ops::CheckpointNotifyOp, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::CheckpointNotifyOpMaker, ops::CheckpointNotifyOpShapeInference); diff --git a/paddle/fluid/operators/distributed_ops/distributed_notify_op.cc b/paddle/fluid/operators/distributed_ops/distributed_notify_op.cc index 5e15b11655d346b360472d6f206bd1a46d709197..58c1b6486b0a3e680369d4b1451ed7048bb5a5e9 100644 --- a/paddle/fluid/operators/distributed_ops/distributed_notify_op.cc +++ b/paddle/fluid/operators/distributed_ops/distributed_notify_op.cc @@ -78,7 +78,8 @@ class DistributedNotifyOpShapeInference : public framework::InferShapeBase { namespace ops = paddle::operators; -REGISTER_OPERATOR(distributed_notify, ops::DistributedNotifyOp, - paddle::framework::EmptyGradOpMaker, - ops::DistributedNotifyOpMaker, - ops::DistributedNotifyOpShapeInference); +REGISTER_OPERATOR( + distributed_notify, ops::DistributedNotifyOp, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::DistributedNotifyOpMaker, ops::DistributedNotifyOpShapeInference); diff --git a/paddle/fluid/operators/distributed_ops/fake_init_op.cc b/paddle/fluid/operators/distributed_ops/fake_init_op.cc index 5ee35e0458a64dacc1c469a435edd28de1b78e6b..b56ab1d5fd6d2da086fa6d3fb02df8a66d550b41 100644 --- a/paddle/fluid/operators/distributed_ops/fake_init_op.cc +++ b/paddle/fluid/operators/distributed_ops/fake_init_op.cc @@ -80,6 +80,8 @@ table parameter at trainer side in distributed lookup table. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(fake_init, ops::FakeInitOp, ops::FakeInitInferShape, - ops::FakeInitOpMaker, paddle::framework::EmptyGradOpMaker, - ops::FakeInitOpVarTypeInference); +REGISTER_OPERATOR( + fake_init, ops::FakeInitOp, ops::FakeInitInferShape, ops::FakeInitOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::FakeInitOpVarTypeInference); diff --git a/paddle/fluid/operators/distributed_ops/fetch_barrier_op.cc b/paddle/fluid/operators/distributed_ops/fetch_barrier_op.cc index 8a752690857d03d0ba05b41ee8d58c02d6336e56..f0ed7e19254590cf1d7979cbbbad02491d64193f 100644 --- a/paddle/fluid/operators/distributed_ops/fetch_barrier_op.cc +++ b/paddle/fluid/operators/distributed_ops/fetch_barrier_op.cc @@ -85,6 +85,8 @@ class FetchBarrierOpShapeInference : public framework::InferShapeBase { namespace ops = paddle::operators; -REGISTER_OPERATOR(fetch_barrier, ops::FetchBarrierOp, - paddle::framework::EmptyGradOpMaker, ops::FetchBarrierOpMaker, - ops::FetchBarrierOpShapeInference); +REGISTER_OPERATOR( + fetch_barrier, ops::FetchBarrierOp, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::FetchBarrierOpMaker, ops::FetchBarrierOpShapeInference); diff --git a/paddle/fluid/operators/distributed_ops/prefetch_op.cc b/paddle/fluid/operators/distributed_ops/prefetch_op.cc index 52b96d5f8ef7851aa0a99c1d64771f1dc84c66ad..c6395289f8f77552f929222922f851b2db494f94 100644 --- a/paddle/fluid/operators/distributed_ops/prefetch_op.cc +++ b/paddle/fluid/operators/distributed_ops/prefetch_op.cc @@ -95,6 +95,8 @@ class PrefetchOpShapeInference : public framework::InferShapeBase { namespace ops = paddle::operators; -REGISTER_OPERATOR(prefetch, ops::PrefetchOp, - paddle::framework::EmptyGradOpMaker, ops::PrefetchOpMaker, - ops::PrefetchOpShapeInference); +REGISTER_OPERATOR( + prefetch, ops::PrefetchOp, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::PrefetchOpMaker, ops::PrefetchOpShapeInference); diff --git a/paddle/fluid/operators/distributed_ops/recv_op.cc b/paddle/fluid/operators/distributed_ops/recv_op.cc index 30a161fe2565e2f8fc6c86537b17d82a5905deac..a2b7f2f312b4c6647c0fc6f004ef9ab89d6bad05 100644 --- a/paddle/fluid/operators/distributed_ops/recv_op.cc +++ b/paddle/fluid/operators/distributed_ops/recv_op.cc @@ -138,5 +138,8 @@ class RecvOpShapeInference : public framework::InferShapeBase { namespace ops = paddle::operators; -REGISTER_OPERATOR(recv, ops::RecvOp, paddle::framework::EmptyGradOpMaker, - ops::RecvOpMaker, ops::RecvOpShapeInference); +REGISTER_OPERATOR( + recv, ops::RecvOp, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::RecvOpMaker, ops::RecvOpShapeInference); diff --git a/paddle/fluid/operators/distributed_ops/send_barrier_op.cc b/paddle/fluid/operators/distributed_ops/send_barrier_op.cc index 558d0090d734b8f4dc1c2b5ac4e894573cecfc7e..7e4f3647b37e53a6f6f1ab416cf5d88949694f6a 100644 --- a/paddle/fluid/operators/distributed_ops/send_barrier_op.cc +++ b/paddle/fluid/operators/distributed_ops/send_barrier_op.cc @@ -89,6 +89,8 @@ class SendBarrierOpShapeInference : public framework::InferShapeBase { namespace ops = paddle::operators; -REGISTER_OPERATOR(send_barrier, ops::SendBarrierOp, - paddle::framework::EmptyGradOpMaker, ops::SendBarrierOpMaker, - ops::SendBarrierOpShapeInference); +REGISTER_OPERATOR( + send_barrier, ops::SendBarrierOp, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::SendBarrierOpMaker, ops::SendBarrierOpShapeInference); diff --git a/paddle/fluid/operators/distributed_ops/send_op.cc b/paddle/fluid/operators/distributed_ops/send_op.cc index 6fff3317f2293f3cb9208ea920175fa6ed82f8c8..0f5af6973ab96ac4f78049907ccb99be1f0b37b5 100644 --- a/paddle/fluid/operators/distributed_ops/send_op.cc +++ b/paddle/fluid/operators/distributed_ops/send_op.cc @@ -126,5 +126,8 @@ class SendOpShapeInference : public framework::InferShapeBase { namespace ops = paddle::operators; -REGISTER_OPERATOR(send, ops::SendOp, paddle::framework::EmptyGradOpMaker, - ops::SendOpMaker, ops::SendOpShapeInference); +REGISTER_OPERATOR( + send, ops::SendOp, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::SendOpMaker, ops::SendOpShapeInference); diff --git a/paddle/fluid/operators/distributed_ops/split_byref_op.cc b/paddle/fluid/operators/distributed_ops/split_byref_op.cc index 43980107c14176f1751a3db2858c80cb65c764de..79d9c272e8b4e5241ec5f5d79a706fd5376788d9 100644 --- a/paddle/fluid/operators/distributed_ops/split_byref_op.cc +++ b/paddle/fluid/operators/distributed_ops/split_byref_op.cc @@ -97,6 +97,7 @@ namespace ops = paddle::operators; USE_CPU_ONLY_OP(concat); REGISTER_OPERATOR(split_byref, ops::SplitByrefOp, ops::SplitByrefOpMaker, - ops::SplitGradMaker); + ops::SplitGradMaker, + ops::SplitGradMaker); REGISTER_OP_CPU_KERNEL( split_byref, ops::SplitByrefOpKernel); diff --git a/paddle/fluid/operators/dropout_op.cc b/paddle/fluid/operators/dropout_op.cc index 0e060c3a1a339f3ae9e40d6eaadf47d0f8bc566b..597d446b00a61f3b9fc60535d98efa900d860074 100644 --- a/paddle/fluid/operators/dropout_op.cc +++ b/paddle/fluid/operators/dropout_op.cc @@ -127,18 +127,19 @@ class DropoutOpGrad : public framework::OperatorWithKernel { } }; -class DropoutGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class DropoutGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("dropout_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput("Mask", Output("Mask")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput("Mask", this->Output("Mask")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -148,7 +149,8 @@ class DropoutGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(dropout, ops::DropoutOp, ops::DropoutOpMaker, - ops::DropoutGradOpDescMaker); + ops::DropoutGradOpMaker, + ops::DropoutGradOpMaker); REGISTER_OPERATOR(dropout_grad, ops::DropoutOpGrad); REGISTER_OP_CPU_KERNEL( dropout, ops::CPUDropoutKernel, diff --git a/paddle/fluid/operators/edit_distance_op.cc b/paddle/fluid/operators/edit_distance_op.cc index a854d470dddab074813d99f8c64d2e68ec291892..e12206cccc2d905bc370320cb3c63ddbedb11350 100644 --- a/paddle/fluid/operators/edit_distance_op.cc +++ b/paddle/fluid/operators/edit_distance_op.cc @@ -122,7 +122,9 @@ will be divided by the length of reference string. namespace ops = paddle::operators; -REGISTER_OPERATOR(edit_distance, ops::EditDistanceOp, ops::EditDistanceOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + edit_distance, ops::EditDistanceOp, ops::EditDistanceOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( edit_distance, ops::EditDistanceKernel); diff --git a/paddle/fluid/operators/elementwise/elementwise_add_op.cc b/paddle/fluid/operators/elementwise/elementwise_add_op.cc index 922e6904ed7bb7c9db308cd20ff5bbf7e5261948..536e6cba404090b84c01fd115ec54e15860b7bcd 100644 --- a/paddle/fluid/operators/elementwise/elementwise_add_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_add_op.cc @@ -70,23 +70,23 @@ class ElementwiseAddOpMaker : public ElementwiseOpMaker { } }; -class ElementwiseAddDoubleGradDescMaker - : public framework::SingleGradOpDescMaker { +template +class ElementwiseAddDoubleGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("elementwise_add_grad_grad"); - op->SetInput("Y", Input("Y")); - op->SetInput("DOut", Input(framework::GradVarName("Out"))); - op->SetInput("DDX", OutputGrad(framework::GradVarName("X"))); - op->SetInput("DDY", OutputGrad(framework::GradVarName("Y"))); + op->SetInput("Y", this->Input("Y")); + op->SetInput("DOut", this->Input(framework::GradVarName("Out"))); + op->SetInput("DDX", this->OutputGrad(framework::GradVarName("X"))); + op->SetInput("DDY", this->OutputGrad(framework::GradVarName("Y"))); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput("DDOut", InputGrad(framework::GradVarName("Out"))); + op->SetOutput("DDOut", this->InputGrad(framework::GradVarName("Out"))); return op; } }; @@ -98,11 +98,12 @@ REGISTER_ELEMWISE_GRAD_MAKER(elementwise_add, Add); REGISTER_ELEMWISE_EXPLICIT_OP_WITHOUT_GRAD(elementwise_add, Add); namespace ops = paddle::operators; +REGISTER_OPERATOR( + elementwise_add_grad, ops::ElementwiseOpExplicitGrad, + ops::ElementwiseGradOpInplace, ops::ElementwiseGradNoBufVarsInference, + ops::ElementwiseAddDoubleGradMaker, + ops::ElementwiseAddDoubleGradMaker); -REGISTER_OPERATOR(elementwise_add_grad, ops::ElementwiseOpExplicitGrad, - ops::ElementwiseGradOpInplace, - ops::ElementwiseGradNoBufVarsInference, - ops::ElementwiseAddDoubleGradDescMaker); REGISTER_OPERATOR(elementwise_add_grad_grad, ops::ElementwiseOpDoubleGradWithoutDXDY, ops::ElementwiseDoubleGradOpInplace, diff --git a/paddle/fluid/operators/elementwise/elementwise_div_op.cc b/paddle/fluid/operators/elementwise/elementwise_div_op.cc index 507b5a4ed7a200683ca70ddc601133ba00be719a..4459555102c48dbb4a52f5cd23ad8c7127337ab2 100644 --- a/paddle/fluid/operators/elementwise/elementwise_div_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_div_op.cc @@ -67,44 +67,45 @@ class ElementwiseDivOpMaker : public ElementwiseOpMaker { } }; -class ElementwiseDivGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class ElementwiseDivGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("elementwise_div_grad"); - op->SetInput("Y", Input("Y")); - op->SetInput("Out", Output("Out")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); - op->SetAttrMap(Attrs()); + op->SetInput("Y", this->Input("Y")); + op->SetInput("Out", this->Output("Out")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); + op->SetAttrMap(this->Attrs()); return op; } }; -class ElementwiseDivDoubleGradDescMaker - : public framework::SingleGradOpDescMaker { +template +class ElementwiseDivDoubleGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("elementwise_div_grad_grad"); - op->SetInput("Y", Input("Y")); - op->SetInput("Out", Input("Out")); - op->SetInput("DDX", OutputGrad(framework::GradVarName("X"))); - op->SetInput("DDY", OutputGrad(framework::GradVarName("Y"))); - op->SetInput("DX", Output(framework::GradVarName("X"))); + op->SetInput("Y", this->Input("Y")); + op->SetInput("Out", this->Input("Out")); + op->SetInput("DDX", this->OutputGrad(framework::GradVarName("X"))); + op->SetInput("DDY", this->OutputGrad(framework::GradVarName("Y"))); + op->SetInput("DX", this->Output(framework::GradVarName("X"))); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); - op->SetOutput("DOut", InputGrad("Out")); - op->SetOutput("DDOut", InputGrad(framework::GradVarName("Out"))); + op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); + op->SetOutput("DOut", this->InputGrad("Out")); + op->SetOutput("DDOut", this->InputGrad(framework::GradVarName("Out"))); return op; } @@ -117,10 +118,14 @@ namespace ops = paddle::operators; REGISTER_OPERATOR(elementwise_div, ops::ElementwiseOp, ops::ElementwiseDivOpMaker, ops::ElementwiseOpInferVarType, - ops::ElementwiseDivGradOpDescMaker); + ops::ElementwiseDivGradOpMaker, + ops::ElementwiseDivGradOpMaker); + +REGISTER_OPERATOR( + elementwise_div_grad, ops::ElementwiseOpGrad, + ops::ElementwiseDivDoubleGradMaker, + ops::ElementwiseDivDoubleGradMaker); -REGISTER_OPERATOR(elementwise_div_grad, ops::ElementwiseOpGrad, - ops::ElementwiseDivDoubleGradDescMaker); REGISTER_OPERATOR(elementwise_div_grad_grad, ops::ElementwiseDivOpDoubleGrad, ops::ElementwiseDivDoubleGradOpInplace); diff --git a/paddle/fluid/operators/elementwise/elementwise_max_op.cc b/paddle/fluid/operators/elementwise/elementwise_max_op.cc index 40826c7fefd08c7d4ce2bb872f78a4dbf5f288f8..2b1b7c2ee277d45c1a2cad051726f957da2d1822 100644 --- a/paddle/fluid/operators/elementwise/elementwise_max_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_max_op.cc @@ -43,20 +43,21 @@ class ElementwiseMaxOpMaker : public ElementwiseOpMaker { } }; -class ElementwiseMaxGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class ElementwiseMaxGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("elementwise_max_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Y", Input("Y")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Y", this->Input("Y")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -68,7 +69,8 @@ namespace ops = paddle::operators; REGISTER_OPERATOR(elementwise_max, ops::ElementwiseOp, ops::ElementwiseMaxOpMaker, ops::ElementwiseOpInferVarType, - ops::ElementwiseMaxGradOpDescMaker); + ops::ElementwiseMaxGradOpMaker, + ops::ElementwiseMaxGradOpMaker); REGISTER_OPERATOR(elementwise_max_grad, ops::ElementwiseOpGrad); diff --git a/paddle/fluid/operators/elementwise/elementwise_min_op.cc b/paddle/fluid/operators/elementwise/elementwise_min_op.cc index 9f00fc445a4d359f5bd610b0ef920cb1bc742993..9bea93d6cdd50ca6443b7b0962d4ad3f5e07beb8 100644 --- a/paddle/fluid/operators/elementwise/elementwise_min_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_min_op.cc @@ -43,20 +43,21 @@ class ElementwiseMinOpMaker : public ElementwiseOpMaker { } }; -class ElementwiseMinGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class ElementwiseMinGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("elementwise_min_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Y", Input("Y")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Y", this->Input("Y")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -68,7 +69,8 @@ namespace ops = paddle::operators; REGISTER_OPERATOR(elementwise_min, ops::ElementwiseOp, ops::ElementwiseMinOpMaker, ops::ElementwiseOpInferVarType, - ops::ElementwiseMinGradOpDescMaker); + ops::ElementwiseMinGradOpMaker, + ops::ElementwiseMinGradOpMaker); REGISTER_OPERATOR(elementwise_min_grad, ops::ElementwiseOpGrad); diff --git a/paddle/fluid/operators/elementwise/elementwise_mul_op.cc b/paddle/fluid/operators/elementwise/elementwise_mul_op.cc index d843fb4fd11444949eeb2e331c1cc41335599935..87dc15fadcc7aed7e6b84c88badbe5671faaf194 100644 --- a/paddle/fluid/operators/elementwise/elementwise_mul_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_mul_op.cc @@ -70,44 +70,45 @@ class ElementwiseMulOpMaker : public ElementwiseOpMaker { } }; -class ElementwiseMulOpGradDescMaker : public framework::SingleGradOpDescMaker { +template +class ElementwiseMulOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("elementwise_mul_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Y", Input("Y")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetAttrMap(Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); + op->SetInput("X", this->Input("X")); + op->SetInput("Y", this->Input("Y")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetAttrMap(this->Attrs()); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); return op; } }; -class ElementwiseMulDoubleGradDescMaker - : public framework::SingleGradOpDescMaker { +template +class ElementwiseMulDoubleGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("elementwise_mul_grad_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Y", Input("Y")); - op->SetInput("DOut", Input(framework::GradVarName("Out"))); - op->SetInput("DDX", OutputGrad(framework::GradVarName("X"))); - op->SetInput("DDY", OutputGrad(framework::GradVarName("Y"))); + op->SetInput("X", this->Input("X")); + op->SetInput("Y", this->Input("Y")); + op->SetInput("DOut", this->Input(framework::GradVarName("Out"))); + op->SetInput("DDX", this->OutputGrad(framework::GradVarName("X"))); + op->SetInput("DDY", this->OutputGrad(framework::GradVarName("Y"))); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput("DDOut", InputGrad(framework::GradVarName("Out"))); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); + op->SetOutput("DDOut", this->InputGrad(framework::GradVarName("Out"))); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); return op; } }; @@ -118,9 +119,13 @@ class ElementwiseMulDoubleGradDescMaker namespace ops = paddle::operators; REGISTER_OPERATOR(elementwise_mul, ops::ElementwiseOp, ops::ElementwiseMulOpMaker, ops::ElementwiseOpInferVarType, - ops::ElementwiseMulOpGradDescMaker); -REGISTER_OPERATOR(elementwise_mul_grad, ops::ElementwiseOpGrad, - ops::ElementwiseMulDoubleGradDescMaker); + ops::ElementwiseMulOpGradMaker, + ops::ElementwiseMulOpGradMaker); +REGISTER_OPERATOR( + elementwise_mul_grad, ops::ElementwiseOpGrad, + ops::ElementwiseMulDoubleGradMaker, + ops::ElementwiseMulDoubleGradMaker); + REGISTER_OPERATOR(elementwise_mul_grad_grad, ops::ElementwiseOpDoubleGrad, ops::ElementwiseMulDoubleGradOpInplace); diff --git a/paddle/fluid/operators/elementwise/elementwise_op.h b/paddle/fluid/operators/elementwise/elementwise_op.h index 67babe640441875f882aa2b783eda43b35dacce3..720d5d256427dbff83330cf22177f878e4379a07 100644 --- a/paddle/fluid/operators/elementwise/elementwise_op.h +++ b/paddle/fluid/operators/elementwise/elementwise_op.h @@ -379,59 +379,68 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(ElementwiseDoubleGradNoBufVarsInference, } // namespace operators } // namespace paddle -#define REGISTER_ELEMWISE_GRAD_MAKER(kernel_type, op_name) \ - class kernel_type##GradMaker \ - : public paddle::framework::SingleGradOpDescMaker { \ - public: \ - using ::paddle::framework::SingleGradOpDescMaker::SingleGradOpDescMaker; \ - \ - protected: \ - std::unique_ptr Apply() const override { \ - auto *op = new paddle::framework::OpDesc(); \ - op->SetType(#kernel_type "_grad"); \ - op->SetInput("Y", Input("Y")); \ - op->SetInput(::paddle::framework::GradVarName("Out"), \ - OutputGrad("Out")); \ - op->SetAttrMap(Attrs()); \ - op->SetOutput(::paddle::framework::GradVarName("X"), InputGrad("X")); \ - op->SetOutput(::paddle::framework::GradVarName("Y"), InputGrad("Y")); \ - return std::unique_ptr<::paddle::framework::OpDesc>(op); \ - } \ +#define REGISTER_ELEMWISE_GRAD_MAKER(kernel_type, op_name) \ + template \ + class kernel_type##GradMaker \ + : public paddle::framework::SingleGradOpMaker { \ + public: \ + using ::paddle::framework::SingleGradOpMaker::SingleGradOpMaker; \ + \ + protected: \ + std::unique_ptr Apply() const override { \ + auto *op = new T(); \ + op->SetType(#kernel_type "_grad"); \ + op->SetInput("Y", this->Input("Y")); \ + op->SetInput(::paddle::framework::GradVarName("Out"), \ + this->OutputGrad("Out")); \ + op->SetAttrMap(this->Attrs()); \ + op->SetOutput(::paddle::framework::GradVarName("X"), \ + this->InputGrad("X")); \ + op->SetOutput(::paddle::framework::GradVarName("Y"), \ + this->InputGrad("Y")); \ + return std::unique_ptr(op); \ + } \ } -#define REGISTER_ELEMWISE_OP(op_type, op_name, equation) \ - class __ElemwiseOp##op_type##Maker__ \ - : public ::paddle::operators::ElementwiseOpMaker { \ - protected: \ - virtual std::string GetName() const { return op_name; } \ - virtual std::string GetEquation() const { return equation; } \ - }; \ - REGISTER_OPERATOR(op_type, ::paddle::operators::ElementwiseOp, \ - __ElemwiseOp##op_type##Maker__, \ - ::paddle::operators::ElementwiseOpInferVarType, \ - ::paddle::framework::DefaultGradOpDescMaker); \ +#define REGISTER_ELEMWISE_OP(op_type, op_name, equation) \ + class __ElemwiseOp##op_type##Maker__ \ + : public ::paddle::operators::ElementwiseOpMaker { \ + protected: \ + virtual std::string GetName() const { return op_name; } \ + virtual std::string GetEquation() const { return equation; } \ + }; \ + REGISTER_OPERATOR( \ + op_type, ::paddle::operators::ElementwiseOp, \ + __ElemwiseOp##op_type##Maker__, \ + ::paddle::operators::ElementwiseOpInferVarType, \ + ::paddle::framework::DefaultGradOpMaker<::paddle::framework::OpDesc, \ + true>, \ + ::paddle::framework::DefaultGradOpMaker<::paddle::imperative::OpBase, \ + true>); \ REGISTER_OPERATOR(op_type##_grad, ::paddle::operators::ElementwiseOpGrad) -#define REGISTER_ELEMWISE_EXPLICIT_OP(op_type, op_name, equation) \ - class __ElemwiseOp##op_type##Maker__ \ - : public ::paddle::operators::ElementwiseOpMaker { \ - protected: \ - virtual std::string GetName() const { return op_name; } \ - virtual std::string GetEquation() const { return equation; } \ - }; \ - REGISTER_OPERATOR(op_type, ::paddle::operators::ElementwiseOp, \ - __ElemwiseOp##op_type##Maker__, \ - ::paddle::operators::ElementwiseOpInferVarType, \ - op_type##GradMaker, \ - ::paddle::operators::ElementwiseOpInplace); \ - REGISTER_OPERATOR(op_type##_grad, \ - ::paddle::operators::ElementwiseOpExplicitGrad, \ - ::paddle::operators::ElementwiseGradOpInplace, \ +#define REGISTER_ELEMWISE_EXPLICIT_OP(op_type, op_name, equation) \ + class __ElemwiseOp##op_type##Maker__ \ + : public ::paddle::operators::ElementwiseOpMaker { \ + protected: \ + virtual std::string GetName() const { return op_name; } \ + virtual std::string GetEquation() const { return equation; } \ + }; \ + REGISTER_OPERATOR(op_type, ::paddle::operators::ElementwiseOp, \ + __ElemwiseOp##op_type##Maker__, \ + ::paddle::operators::ElementwiseOpInferVarType, \ + op_type##GradMaker<::paddle::framework::OpDesc>, \ + op_type##GradMaker<::paddle::imperative::OpBase>, \ + ::paddle::operators::ElementwiseOpInplace); \ + REGISTER_OPERATOR(op_type##_grad, \ + ::paddle::operators::ElementwiseOpExplicitGrad, \ + ::paddle::operators::ElementwiseGradOpInplace, \ ::paddle::operators::ElementwiseGradNoBufVarsInference) #define REGISTER_ELEMWISE_EXPLICIT_OP_WITHOUT_GRAD(op_type, op_name) \ REGISTER_OPERATOR(op_type, ::paddle::operators::ElementwiseOp, \ ::paddle::operators::Elementwise##op_name##OpMaker, \ ::paddle::operators::ElementwiseOpInferVarType, \ - op_type##GradMaker, \ + op_type##GradMaker<::paddle::framework::OpDesc>, \ + op_type##GradMaker<::paddle::imperative::OpBase>, \ ::paddle::operators::ElementwiseOpInplace); diff --git a/paddle/fluid/operators/elementwise/elementwise_pow_op.cc b/paddle/fluid/operators/elementwise/elementwise_pow_op.cc index d3e225a7c07924944cddf124e224746b5f8a3cb6..46e4e159ac6a311b3c84db14c3f4f3386dbee11c 100644 --- a/paddle/fluid/operators/elementwise/elementwise_pow_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_pow_op.cc @@ -17,20 +17,21 @@ limitations under the License. */ namespace paddle { namespace operators { -class ElementwisePowOpGradDescMaker : public framework::SingleGradOpDescMaker { +template +class ElementwisePowOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("elementwise_pow_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Y", Input("Y")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetAttrMap(Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); + op->SetInput("X", this->Input("X")); + op->SetInput("Y", this->Input("Y")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetAttrMap(this->Attrs()); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); return op; } }; @@ -54,7 +55,8 @@ class ElementwisePowOpMaker : public ElementwiseOpMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(elementwise_pow, ops::ElementwiseOp, ops::ElementwisePowOpMaker, ops::ElementwiseOpInferVarType, - ops::ElementwisePowOpGradDescMaker); + ops::ElementwisePowOpGradMaker, + ops::ElementwisePowOpGradMaker); REGISTER_OPERATOR(elementwise_pow_grad, ops::ElementwiseOpGrad); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/elementwise/elementwise_sub_op.cc b/paddle/fluid/operators/elementwise/elementwise_sub_op.cc index 48979348218c7d04dc1f14b79ba39e6bc15a5b59..480f41030f3fab954eb2ccd8f333a5e3ef7c9c54 100644 --- a/paddle/fluid/operators/elementwise/elementwise_sub_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_sub_op.cc @@ -69,23 +69,23 @@ class ElementwiseSubOpMaker : public ElementwiseOpMaker { } }; -class ElementwiseSubDoubleGradDescMaker - : public framework::SingleGradOpDescMaker { +template +class ElementwiseSubDoubleGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("elementwise_sub_grad_grad"); - op->SetInput("Y", Input("Y")); - op->SetInput("DOut", Input(framework::GradVarName("Out"))); - op->SetInput("DDX", OutputGrad(framework::GradVarName("X"))); - op->SetInput("DDY", OutputGrad(framework::GradVarName("Y"))); + op->SetInput("Y", this->Input("Y")); + op->SetInput("DOut", this->Input(framework::GradVarName("Out"))); + op->SetInput("DDX", this->OutputGrad(framework::GradVarName("X"))); + op->SetInput("DDY", this->OutputGrad(framework::GradVarName("Y"))); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput("DDOut", InputGrad(framework::GradVarName("Out"))); + op->SetOutput("DDOut", this->InputGrad(framework::GradVarName("Out"))); return op; } }; @@ -97,10 +97,11 @@ namespace ops = paddle::operators; REGISTER_ELEMWISE_GRAD_MAKER(elementwise_sub, Sub); REGISTER_ELEMWISE_EXPLICIT_OP_WITHOUT_GRAD(elementwise_sub, Sub); -REGISTER_OPERATOR(elementwise_sub_grad, ops::ElementwiseOpExplicitGrad, - ops::ElementwiseGradOpInplace, - ops::ElementwiseGradNoBufVarsInference, - ops::ElementwiseSubDoubleGradDescMaker); +REGISTER_OPERATOR( + elementwise_sub_grad, ops::ElementwiseOpExplicitGrad, + ops::ElementwiseGradOpInplace, ops::ElementwiseGradNoBufVarsInference, + ops::ElementwiseSubDoubleGradMaker, + ops::ElementwiseSubDoubleGradMaker); REGISTER_OPERATOR(elementwise_sub_grad_grad, ops::ElementwiseOpDoubleGradWithoutDXDY, ops::ElementwiseDoubleGradOpInplace, diff --git a/paddle/fluid/operators/expand_as_op.cc b/paddle/fluid/operators/expand_as_op.cc index 204a93df23d6e701e071c265133412e435b2142b..002623c1b17f5bea2a4f58be93665a97121723e3 100644 --- a/paddle/fluid/operators/expand_as_op.cc +++ b/paddle/fluid/operators/expand_as_op.cc @@ -90,19 +90,20 @@ class ExpandAsGradOp : public framework::OperatorWithKernel { } }; -class ExpandAsGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class ExpandAsGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("expand_as_grad"); - op->SetInput("X", Input("X")); - op->SetInput("target_tensor", Input("target_tensor")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("target_tensor", this->Input("target_tensor")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -114,7 +115,8 @@ class ExpandAsGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(expand_as, ops::ExpandAsOp, ops::ExpandAsOpMaker, - ops::ExpandAsGradOpDescMaker); + ops::ExpandAsGradOpMaker, + ops::ExpandAsGradOpMaker); REGISTER_OPERATOR(expand_as_grad, ops::ExpandAsGradOp); REGISTER_OP_CPU_KERNEL( expand_as, ops::ExpandAsKernel, diff --git a/paddle/fluid/operators/expand_op.cc b/paddle/fluid/operators/expand_op.cc index 41147b77ee0585e2427e065ffb2cd9d23373e7d2..fadd65fad30e49cd067292fc6f8fb5f3adef88ad 100644 --- a/paddle/fluid/operators/expand_op.cc +++ b/paddle/fluid/operators/expand_op.cc @@ -197,20 +197,21 @@ class ExpandGradOp : public framework::OperatorWithKernel { } }; -class ExpandGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class ExpandGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("expand_grad"); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetInput("expand_times_tensor", Input("expand_times_tensor")); - op->SetInput("ExpandTimes", Input("ExpandTimes")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetInput("expand_times_tensor", this->Input("expand_times_tensor")); + op->SetInput("ExpandTimes", this->Input("ExpandTimes")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -222,7 +223,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(ExpandGradNoNeedBufVarsInferer, "X"); namespace ops = paddle::operators; REGISTER_OPERATOR(expand, ops::ExpandOp, ops::ExpandOpMaker, - ops::ExpandGradOpDescMaker); + ops::ExpandGradOpMaker, + ops::ExpandGradOpMaker); REGISTER_OPERATOR(expand_grad, ops::ExpandGradOp, ops::ExpandGradNoNeedBufVarsInferer); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/eye_op.cc b/paddle/fluid/operators/eye_op.cc index 40848b963350202b684dbfb7625eb8d4427bdb4a..e7fd1a447342ebe9d037d608013638ad2a645d76 100644 --- a/paddle/fluid/operators/eye_op.cc +++ b/paddle/fluid/operators/eye_op.cc @@ -82,8 +82,10 @@ namespace ops = paddle::operators; using CPU = paddle::platform::CPUDeviceContext; using float16 = paddle::platform::float16; -REGISTER_OPERATOR(eye, ops::EyeOp, ops::EyeOpMaker, ops::EyeOpVarTypeInference, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + eye, ops::EyeOp, ops::EyeOpMaker, ops::EyeOpVarTypeInference, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(eye, ops::EyeKernel, ops::EyeKernel, diff --git a/paddle/fluid/operators/fake_dequantize_op.cc b/paddle/fluid/operators/fake_dequantize_op.cc index 4a8937ba1c7ef9827ecc9bf575d9893c95a3b22b..e01adae4dd8f59b29121fe5b05c1080b3d9e8fb1 100644 --- a/paddle/fluid/operators/fake_dequantize_op.cc +++ b/paddle/fluid/operators/fake_dequantize_op.cc @@ -183,17 +183,21 @@ Notes: In general, the per-channel quantization is only applied to weights and t namespace ops = paddle::operators; using CPU = paddle::platform::CPUDeviceContext; -REGISTER_OPERATOR(fake_dequantize_max_abs, ops::FakeDequantizeMaxAbsOp, - ops::FakeDequantizeMaxAbsOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + fake_dequantize_max_abs, ops::FakeDequantizeMaxAbsOp, + ops::FakeDequantizeMaxAbsOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(fake_dequantize_max_abs, ops::FakeDequantizeMaxAbsKernel, ops::FakeDequantizeMaxAbsKernel); -REGISTER_OPERATOR(fake_channel_wise_dequantize_max_abs, - ops::FakeChannelWiseDequantizeMaxAbsOp, - ops::FakeChannelWiseDequantizeMaxAbsOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + fake_channel_wise_dequantize_max_abs, + ops::FakeChannelWiseDequantizeMaxAbsOp, + ops::FakeChannelWiseDequantizeMaxAbsOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(fake_channel_wise_dequantize_max_abs, ops::FakeChannelWiseDequantizeMaxAbsKernel, ops::FakeChannelWiseDequantizeMaxAbsKernel); diff --git a/paddle/fluid/operators/fake_quantize_op.cc b/paddle/fluid/operators/fake_quantize_op.cc index 53cdcc9922639812450692a6d8f9ebe27a5dd14d..085356f77df5f61912afffe4c4158a83fe2253e4 100644 --- a/paddle/fluid/operators/fake_quantize_op.cc +++ b/paddle/fluid/operators/fake_quantize_op.cc @@ -493,43 +493,54 @@ $$Out = X$$ namespace ops = paddle::operators; using CPU = paddle::platform::CPUDeviceContext; -REGISTER_OPERATOR(fake_quantize_abs_max, ops::FakeQuantizeAbsMaxOp, - ops::FakeQuantizeAbsMaxOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + fake_quantize_abs_max, ops::FakeQuantizeAbsMaxOp, + ops::FakeQuantizeAbsMaxOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(fake_quantize_abs_max, ops::FakeQuantizeAbsMaxKernel); -REGISTER_OPERATOR(fake_quantize_range_abs_max, ops::FakeQuantizeRangeAbsMaxOp, - ops::FakeQuantizeRangeAbsMaxOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + fake_quantize_range_abs_max, ops::FakeQuantizeRangeAbsMaxOp, + ops::FakeQuantizeRangeAbsMaxOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(fake_quantize_range_abs_max, ops::FakeQuantizeRangeAbsMaxKernel); -REGISTER_OPERATOR(fake_quantize_moving_average_abs_max, - ops::FakeQuantOrWithDequantMovingAverageAbsMaxOp, - ops::FakeQuantOrWithDequantMovingAverageAbsMaxOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + fake_quantize_moving_average_abs_max, + ops::FakeQuantOrWithDequantMovingAverageAbsMaxOp, + ops::FakeQuantOrWithDequantMovingAverageAbsMaxOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(fake_quantize_moving_average_abs_max, ops::FakeQuantizeMovingAverageAbsMaxKernel); -REGISTER_OPERATOR(fake_quantize_dequantize_moving_average_abs_max, - ops::FakeQuantOrWithDequantMovingAverageAbsMaxOp, - ops::FakeQuantOrWithDequantMovingAverageAbsMaxOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + fake_quantize_dequantize_moving_average_abs_max, + ops::FakeQuantOrWithDequantMovingAverageAbsMaxOp, + ops::FakeQuantOrWithDequantMovingAverageAbsMaxOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( fake_quantize_dequantize_moving_average_abs_max, ops::FakeQuantizeDequantizeMovingAverageAbsMaxKernel); -REGISTER_OPERATOR(fake_channel_wise_quantize_abs_max, - ops::FakeChannelWiseQuantizeAbsMaxOp, - ops::FakeChannelWiseQuantizeAbsMaxOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + fake_channel_wise_quantize_abs_max, ops::FakeChannelWiseQuantizeAbsMaxOp, + ops::FakeChannelWiseQuantizeAbsMaxOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(fake_channel_wise_quantize_abs_max, ops::FakeChannelWiseQuantizeAbsMaxKernel); -REGISTER_OPERATOR(moving_average_abs_max_scale, ops::MovingAverageAbsMaxScaleOp, - ops::MovingAverageAbsMaxScaleOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + moving_average_abs_max_scale, ops::MovingAverageAbsMaxScaleOp, + ops::MovingAverageAbsMaxScaleOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(moving_average_abs_max_scale, ops::MovingAverageAbsMaxScaleKernel); diff --git a/paddle/fluid/operators/fc_op.cc b/paddle/fluid/operators/fc_op.cc index f831d1173e2ce6c19836682c773e8c88c7270784..5a3e1bb7fdabc6995e547264bd11f5f8cf0b7c25 100644 --- a/paddle/fluid/operators/fc_op.cc +++ b/paddle/fluid/operators/fc_op.cc @@ -123,8 +123,11 @@ The size of each dimension of the parameters checked in the infer-shape. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(fc, ops::FCOp, ops::FCOpMaker, - paddle::framework::EmptyGradOpMaker); + +REGISTER_OPERATOR( + fc, ops::FCOp, ops::FCOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( fc, ops::FCOpKernel, ops::FCOpKernel); diff --git a/paddle/fluid/operators/fill_constant_batch_size_like_op.cc b/paddle/fluid/operators/fill_constant_batch_size_like_op.cc index 404c2a92a47f90dff780c374eaae51d61a041d33..087463df91d18985707f3d6e6748cd924da03af9 100644 --- a/paddle/fluid/operators/fill_constant_batch_size_like_op.cc +++ b/paddle/fluid/operators/fill_constant_batch_size_like_op.cc @@ -56,11 +56,12 @@ obtained from the `input` tensor. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(fill_constant_batch_size_like, - ops::FillConstantBatchSizeLikeOp, - paddle::framework::EmptyGradOpMaker, - ops::FillConstantBatchSizeLikeOpMaker, - ops::BatchSizeLikeNoNeedBufferVarsInference); +REGISTER_OPERATOR( + fill_constant_batch_size_like, ops::FillConstantBatchSizeLikeOp, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::FillConstantBatchSizeLikeOpMaker, + ops::BatchSizeLikeNoNeedBufferVarsInference); REGISTER_OP_CPU_KERNEL( fill_constant_batch_size_like, ops::FillConstantBatchSizeLikeOpKernel, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(fill_constant, ops::FillConstantKernel, ops::FillConstantKernel, diff --git a/paddle/fluid/operators/fill_op.cc b/paddle/fluid/operators/fill_op.cc index 4f7cfcf112a0595641b16447b417cbe86db31120..a13eff7f8da88917f49f4b26275071f816e5b235 100644 --- a/paddle/fluid/operators/fill_op.cc +++ b/paddle/fluid/operators/fill_op.cc @@ -72,9 +72,10 @@ class FillOpVarTypeInference : public framework::VarTypeInference { } // namespace operators } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(fill, ops::FillOp, ops::FillOpMaker, - ops::FillOpVarTypeInference, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + fill, ops::FillOp, ops::FillOpMaker, ops::FillOpVarTypeInference, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(fill, ops::FillKernel, ops::FillKernel, ops::FillKernel, ops::FillKernel, ops::FillKernel); diff --git a/paddle/fluid/operators/fill_zeros_like_op.cc b/paddle/fluid/operators/fill_zeros_like_op.cc index 107f83e3f885bcd5a71aaf1e51cbd0bd39b676f0..00cc1f6e0b6e0ddb785a229ff66009892c534121 100644 --- a/paddle/fluid/operators/fill_zeros_like_op.cc +++ b/paddle/fluid/operators/fill_zeros_like_op.cc @@ -83,10 +83,11 @@ namespace ops = paddle::operators; REGISTER_OP_WITHOUT_GRADIENT(fill_zeros_like, ops::FillZerosLikeOp, ops::FillZerosLikeOpMaker); -REGISTER_OPERATOR(fill_zeros_like2, ops::FillZerosLikeOp2, - ops::FillZerosLikeOp2Maker, - ops::FillZerosLikeOp2NoNeedBufferVarsInference, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + fill_zeros_like2, ops::FillZerosLikeOp2, ops::FillZerosLikeOp2Maker, + ops::FillZerosLikeOp2NoNeedBufferVarsInference, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( fill_zeros_like, diff --git a/paddle/fluid/operators/filter_by_instag_op.cc b/paddle/fluid/operators/filter_by_instag_op.cc index a48c901f9e6d4431e8a9aa3efe0a70089bbdd92e..b156246f04bb168f55be2db5d7d44b458c2710bb 100644 --- a/paddle/fluid/operators/filter_by_instag_op.cc +++ b/paddle/fluid/operators/filter_by_instag_op.cc @@ -107,20 +107,21 @@ class FilterByInstagOpGrad : public framework::OperatorWithKernel { } }; -class FilterByInstagGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class FilterByInstagGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("filter_by_instag_grad"); - op->SetInput("IndexMap", Output("IndexMap")); - op->SetInput("Ins", Input("Ins")); - op->SetAttrMap(Attrs()); - op->SetInput("LossWeight", Output("LossWeight")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("Ins"), InputGrad("Ins")); + op->SetInput("IndexMap", this->Output("IndexMap")); + op->SetInput("Ins", this->Input("Ins")); + op->SetAttrMap(this->Attrs()); + op->SetInput("LossWeight", this->Output("LossWeight")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("Ins"), this->InputGrad("Ins")); return op; } }; @@ -130,7 +131,8 @@ class FilterByInstagGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(filter_by_instag, ops::FilterByInstagOp, ops::FilterByInstagOpMaker, - ops::FilterByInstagGradOpDescMaker); + ops::FilterByInstagGradOpMaker, + ops::FilterByInstagGradOpMaker); REGISTER_OPERATOR(filter_by_instag_grad, ops::FilterByInstagOpGrad); diff --git a/paddle/fluid/operators/flatten_op.cc b/paddle/fluid/operators/flatten_op.cc index c27bb1606b346f9cd607f74e3b9a21013918e5f5..320e132d22236acea4d25bbcc48e6372511330ec 100644 --- a/paddle/fluid/operators/flatten_op.cc +++ b/paddle/fluid/operators/flatten_op.cc @@ -190,18 +190,19 @@ class Flatten2OpMaker : public FlattenOpMaker { } }; -class Flatten2GradOpMaker : public framework::SingleGradOpDescMaker { +template +class Flatten2GradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("flatten2_grad"); - grad_op->SetInput("XShape", Output("XShape")); - grad_op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - grad_op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("XShape", this->Output("XShape")); + grad_op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + grad_op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -238,14 +239,18 @@ DECLARE_INPLACE_OP_INFERER(FlattenGradInplaceinToOut, } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(flatten, ops::FlattenOp, ops::FlattenOpMaker, - paddle::framework::DefaultGradOpDescMaker, - ops::FlattenOpInplaceInToOut); +REGISTER_OPERATOR( + flatten, ops::FlattenOp, ops::FlattenOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker, + ops::FlattenOpInplaceInToOut); REGISTER_OPERATOR(flatten_grad, ops::FlattenGradOp, ops::FlattenGradInplaceinToOut); REGISTER_OPERATOR(flatten2, ops::Flatten2Op, ops::Flatten2OpMaker, - ops::Flatten2GradOpMaker, ops::FlattenOpInplaceInToOut); + ops::Flatten2GradOpMaker, + ops::Flatten2GradOpMaker, + ops::FlattenOpInplaceInToOut); REGISTER_OPERATOR(flatten2_grad, ops::Flatten2GradOp, ops::FlattenGradInplaceinToOut); diff --git a/paddle/fluid/operators/fsp_op.cc b/paddle/fluid/operators/fsp_op.cc index 0706f9ce3769a7b8e497f7d924d8ac553b12de68..020b03e3eea36644e52c66d268009956ea00927b 100644 --- a/paddle/fluid/operators/fsp_op.cc +++ b/paddle/fluid/operators/fsp_op.cc @@ -118,8 +118,10 @@ class FSPOpGrad : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(fsp, ops::FSPOp, ops::FSPOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + fsp, ops::FSPOp, ops::FSPOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(fsp_grad, ops::FSPOpGrad); REGISTER_OP_CPU_KERNEL( fsp, ops::FSPOpKernel, diff --git a/paddle/fluid/operators/fused/conv_fusion_op.cc b/paddle/fluid/operators/fused/conv_fusion_op.cc index dd74d278111002dfee7a77b06c7126cceaa2afc1..30dd35db9ed698a4f1f3ebbba13808cac182da18 100644 --- a/paddle/fluid/operators/fused/conv_fusion_op.cc +++ b/paddle/fluid/operators/fused/conv_fusion_op.cc @@ -103,6 +103,8 @@ class Conv2DFusionOpInferShape : public framework::InferShapeBase { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(conv2d_fusion, ops::ConvOp, ops::Conv2DFusionOpMaker, - ops::Conv2DFusionOpInferShape, ops::ConvOpInferVarType, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + conv2d_fusion, ops::ConvOp, ops::Conv2DFusionOpMaker, + ops::Conv2DFusionOpInferShape, ops::ConvOpInferVarType, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/fused/fused_elemwise_activation_op.cc b/paddle/fluid/operators/fused/fused_elemwise_activation_op.cc index 9a156147aa4c65280844a7277e8576daca3cb6e1..e60534f0ef87c6fd5fc2af17cdaa7ba229e0b65c 100644 --- a/paddle/fluid/operators/fused/fused_elemwise_activation_op.cc +++ b/paddle/fluid/operators/fused/fused_elemwise_activation_op.cc @@ -220,14 +220,15 @@ The functor_list records the functions to be fused, for example } }; +template class FusedElemwiseActivationGradMaker - : public framework::SingleGradOpDescMaker { + : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType(this->ForwardOpType() + "_grad"); for (auto &input_param : this->InputNames()) { @@ -249,7 +250,7 @@ class FusedElemwiseActivationGradMaker grad_op->SetAttr("functor_list", functor_names); if (boost::get(grad_op->GetAttr("save_intermediate_out"))) { - PADDLE_ENFORCE_NE(Output("IntermediateOut").size(), 0); + // PADDLE_ENFORCE_NE(Output("IntermediateOut").size(), 0); grad_op->SetInput("IntermediateOut", this->Output("IntermediateOut")); grad_op->SetOutput(framework::GradVarName("IntermediateOut"), this->OutputGrad("IntermediateOut")); @@ -258,7 +259,7 @@ class FusedElemwiseActivationGradMaker grad_op->SetOutput(framework::GradVarName("IntermediateOut"), {}); } - return std::unique_ptr(grad_op); + return std::unique_ptr(grad_op); } }; @@ -336,9 +337,11 @@ class FusedElemwiseActivationOpGrad : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(fused_elemwise_activation, ops::FusedElemwiseActivationOp, - ops::FusedElemwiseActivationMaker, - ops::FusedElemwiseActivationGradMaker); +REGISTER_OPERATOR( + fused_elemwise_activation, ops::FusedElemwiseActivationOp, + ops::FusedElemwiseActivationMaker, + ops::FusedElemwiseActivationGradMaker, + ops::FusedElemwiseActivationGradMaker); REGISTER_OPERATOR(fused_elemwise_activation_grad, ops::FusedElemwiseActivationOpGrad); diff --git a/paddle/fluid/operators/fused/fused_embedding_seq_pool_op.cc b/paddle/fluid/operators/fused/fused_embedding_seq_pool_op.cc index 727e135c3566e951e015fa1bd2d0d0ed49f5d64a..ee2891f9bbcc7f369a1b25516378bac43d08d8bf 100644 --- a/paddle/fluid/operators/fused/fused_embedding_seq_pool_op.cc +++ b/paddle/fluid/operators/fused/fused_embedding_seq_pool_op.cc @@ -151,20 +151,21 @@ class FusedEmbeddingSeqPoolOpGradVarTypeInference } }; -class FusedEmbeddingSeqPoolGradOpDescMaker - : public framework::SingleGradOpDescMaker { +template +class FusedEmbeddingSeqPoolGradOpMaker + : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("fused_embedding_seq_pool_grad"); - op->SetInput("Ids", Input("Ids")); - op->SetInput("W", Input("W")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("W"), InputGrad("W")); - op->SetAttrMap(Attrs()); + op->SetInput("Ids", this->Input("Ids")); + op->SetInput("W", this->Input("W")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("W"), this->InputGrad("W")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -173,9 +174,12 @@ class FusedEmbeddingSeqPoolGradOpDescMaker } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(fused_embedding_seq_pool, ops::FusedEmbeddingSeqPoolOp, - ops::FusedEmbeddingSeqPoolGradOpDescMaker, - ops::FusedEmbeddingSeqPoolOpMaker); + +REGISTER_OPERATOR( + fused_embedding_seq_pool, ops::FusedEmbeddingSeqPoolOp, + ops::FusedEmbeddingSeqPoolGradOpMaker, + ops::FusedEmbeddingSeqPoolGradOpMaker, + ops::FusedEmbeddingSeqPoolOpMaker); REGISTER_OPERATOR(fused_embedding_seq_pool_grad, ops::FusedEmbeddingSeqPoolOpGrad, ops::FusedEmbeddingSeqPoolOpGradVarTypeInference); diff --git a/paddle/fluid/operators/fused/fused_fc_elementwise_layernorm_op.cc b/paddle/fluid/operators/fused/fused_fc_elementwise_layernorm_op.cc index 7c5d0c71226871a3af10c8ddc16269526f0d88b9..ea7d6a93d1b28c0155647b3db4ed6df749c9a50f 100644 --- a/paddle/fluid/operators/fused/fused_fc_elementwise_layernorm_op.cc +++ b/paddle/fluid/operators/fused/fused_fc_elementwise_layernorm_op.cc @@ -179,7 +179,8 @@ add_out <= elementwise_add(fc_out, Y) } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(fused_fc_elementwise_layernorm, - ops::FusedFCElementwiseLayerNormOp, - ops::FusedFCElementwiseLayerNormOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + fused_fc_elementwise_layernorm, ops::FusedFCElementwiseLayerNormOp, + ops::FusedFCElementwiseLayerNormOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/fused/fusion_conv_inception_op.cc b/paddle/fluid/operators/fused/fusion_conv_inception_op.cc index e18ac13d345e8b2f59172300891434e316435665..60092cfff687bdad6e7e3ad1a7d15faf6f731757 100644 --- a/paddle/fluid/operators/fused/fusion_conv_inception_op.cc +++ b/paddle/fluid/operators/fused/fusion_conv_inception_op.cc @@ -107,6 +107,8 @@ class ConvInceptionFusionOpMaker : public framework::OpProtoAndCheckerMaker { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(conv2d_inception_fusion, ops::ConvInceptionFusionOp, - ops::ConvInceptionFusionOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + conv2d_inception_fusion, ops::ConvInceptionFusionOp, + ops::ConvInceptionFusionOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/fused/fusion_seqpool_cvm_concat_op.cc b/paddle/fluid/operators/fused/fusion_seqpool_cvm_concat_op.cc index 0a245bb05057598bbc41c3753eaf5adaa47f4c0e..f64e4f134d62f125e3e781ebf43163a566587d58 100644 --- a/paddle/fluid/operators/fused/fusion_seqpool_cvm_concat_op.cc +++ b/paddle/fluid/operators/fused/fusion_seqpool_cvm_concat_op.cc @@ -139,9 +139,11 @@ class FusionSeqPoolCVMConcatKernel : public framework::OpKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(fusion_seqpool_cvm_concat, ops::FusionSeqPoolCVMConcatOp, - ops::FusionSeqPoolCVMConcatOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + fusion_seqpool_cvm_concat, ops::FusionSeqPoolCVMConcatOp, + ops::FusionSeqPoolCVMConcatOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(fusion_seqpool_cvm_concat, ops::FusionSeqPoolCVMConcatKernel, diff --git a/paddle/fluid/operators/fused/fusion_transpose_flatten_concat_op.cc b/paddle/fluid/operators/fused/fusion_transpose_flatten_concat_op.cc index 39356c9afccbf9af3eacf99a6bccb15e18f7e485..3127c0259a59e0b59ce5e3e7453d829162341fe9 100644 --- a/paddle/fluid/operators/fused/fusion_transpose_flatten_concat_op.cc +++ b/paddle/fluid/operators/fused/fusion_transpose_flatten_concat_op.cc @@ -108,7 +108,8 @@ class TransposeFlattenConcatFusionOpMaker } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(fusion_transpose_flatten_concat, - ops::TransposeFlattenConcatFusionOp, - ops::TransposeFlattenConcatFusionOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + fusion_transpose_flatten_concat, ops::TransposeFlattenConcatFusionOp, + ops::TransposeFlattenConcatFusionOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/gather_nd_op.cc b/paddle/fluid/operators/gather_nd_op.cc index b2a4029c8f6c86f632b899f264a00a6192cbdad9..f871615d0bda2572e6cbf8cf8cfe0a5315247eae 100644 --- a/paddle/fluid/operators/gather_nd_op.cc +++ b/paddle/fluid/operators/gather_nd_op.cc @@ -144,19 +144,20 @@ class GatherNdOpMaker : public framework::OpProtoAndCheckerMaker { } }; -class GatherNdGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class GatherNdGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("gather_nd_grad"); - op->SetInput("Index", Input("Index")); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("Index", this->Input("Index")); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -170,7 +171,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(GatherNdGradNoNeedBufferVarInference, namespace ops = paddle::operators; REGISTER_OPERATOR(gather_nd, ops::GatherNdOp, ops::GatherNdOpMaker, - ops::GatherNdGradOpDescMaker); + ops::GatherNdGradOpMaker, + ops::GatherNdGradOpMaker); REGISTER_OPERATOR(gather_nd_grad, ops::GatherNdGradOp, ops::GatherNdGradNoNeedBufferVarInference); diff --git a/paddle/fluid/operators/gather_op.cc b/paddle/fluid/operators/gather_op.cc index 075be1caf48f0e96c2349c2060caf2637f55ce41..1f85e30811b13fb95ed531ea8519a4e1fee87036 100644 --- a/paddle/fluid/operators/gather_op.cc +++ b/paddle/fluid/operators/gather_op.cc @@ -107,19 +107,20 @@ Out = [[3, 4], } }; -class GatherGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class GatherGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("gather_grad"); - op->SetInput("Index", Input("Index")); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("Index", this->Input("Index")); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -131,7 +132,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(GatherGradNoNeedBufferVarInference, "X"); namespace ops = paddle::operators; REGISTER_OPERATOR(gather, ops::GatherOp, ops::GatherOpMaker, - ops::GatherGradOpDescMaker); + ops::GatherGradOpMaker, + ops::GatherGradOpMaker); REGISTER_OPERATOR(gather_grad, ops::GatherGradOp, ops::GatherGradNoNeedBufferVarInference); REGISTER_OP_CPU_KERNEL(gather, ops::GatherOpKernel, diff --git a/paddle/fluid/operators/gaussian_random_batch_size_like_op.cc b/paddle/fluid/operators/gaussian_random_batch_size_like_op.cc index daf85139103df76ecb01cae1ee0f858d057a9417..ab7403a8ba5adb2338f8255d16c66d032eb9b314 100644 --- a/paddle/fluid/operators/gaussian_random_batch_size_like_op.cc +++ b/paddle/fluid/operators/gaussian_random_batch_size_like_op.cc @@ -68,10 +68,12 @@ via input arguments. } // namespace operators } // namespace paddle -REGISTER_OPERATOR(gaussian_random_batch_size_like, - paddle::operators::GaussianRandomBatchSizeLikeOp, - paddle::operators::GaussianRandomBatchSizeLikeOpMaker, - paddle::framework::EmptyGradOpMaker, - paddle::operators::BatchSizeLikeNoNeedBufferVarsInference); +REGISTER_OPERATOR( + gaussian_random_batch_size_like, + paddle::operators::GaussianRandomBatchSizeLikeOp, + paddle::operators::GaussianRandomBatchSizeLikeOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::operators::BatchSizeLikeNoNeedBufferVarsInference); // Kernels are registered in gaussian_random_op.cc and gaussian_random_op.cu diff --git a/paddle/fluid/operators/grid_sampler_op.cc b/paddle/fluid/operators/grid_sampler_op.cc index 5338889363af1f4f8eade81a6b966bd5fe86b3e0..244de0e355222d34a63e9f9c453552adcdc86080 100644 --- a/paddle/fluid/operators/grid_sampler_op.cc +++ b/paddle/fluid/operators/grid_sampler_op.cc @@ -170,23 +170,24 @@ class GridSampleOpGrad : public framework::OperatorWithKernel { } }; -class GridSampleGradMaker : public framework::SingleGradOpDescMaker { +template +class GridSampleGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("grid_sampler_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Grid", Input("Grid")); - op->SetInput(framework::GradVarName("Output"), OutputGrad("Output")); + op->SetInput("X", this->Input("X")); + op->SetInput("Grid", this->Input("Grid")); + op->SetInput(framework::GradVarName("Output"), this->OutputGrad("Output")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Grid"), InputGrad("Grid")); - return std::unique_ptr(op); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Grid"), this->InputGrad("Grid")); + return std::unique_ptr(op); } }; @@ -195,7 +196,8 @@ class GridSampleGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(grid_sampler, ops::GridSampleOp, ops::GridSampleOpMaker, - ops::GridSampleGradMaker); + ops::GridSampleGradMaker, + ops::GridSampleGradMaker); REGISTER_OPERATOR(grid_sampler_grad, ops::GridSampleOpGrad); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/group_norm_op.cc b/paddle/fluid/operators/group_norm_op.cc index e184ff14a5534dc40e87af0be45ca3409f1bdb18..7cb85d636fbf0a856878588cfb1e86eb0c74a678 100644 --- a/paddle/fluid/operators/group_norm_op.cc +++ b/paddle/fluid/operators/group_norm_op.cc @@ -151,26 +151,27 @@ class GroupNormGradOp : public framework::OperatorWithKernel { } }; -class GroupNormGradMaker : public framework::SingleGradOpDescMaker { +template +class GroupNormGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto *op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *op = new T(); op->SetType("group_norm_grad"); - op->SetInput("Scale", Input("Scale")); - op->SetInput("Bias", Input("Bias")); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - op->SetInput("Y", Output("Y")); - op->SetInput("Variance", Output("Variance")); + op->SetInput("Scale", this->Input("Scale")); + op->SetInput("Bias", this->Input("Bias")); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + op->SetInput("Y", this->Output("Y")); + op->SetInput("Variance", this->Output("Variance")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Bias"), InputGrad("Bias")); - op->SetOutput(framework::GradVarName("Scale"), InputGrad("Scale")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); + op->SetOutput(framework::GradVarName("Scale"), this->InputGrad("Scale")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - return std::unique_ptr(op); + return std::unique_ptr(op); } }; @@ -193,7 +194,9 @@ class GroupNormOpInferVarType namespace ops = paddle::operators; REGISTER_OPERATOR(group_norm, ops::GroupNormOp, ops::GroupNormOpMaker, - ops::GroupNormOpInferVarType, ops::GroupNormGradMaker, + ops::GroupNormOpInferVarType, + ops::GroupNormGradMaker, + ops::GroupNormGradMaker, ops::GroupNormInplaceInToOut); REGISTER_OPERATOR(group_norm_grad, ops::GroupNormGradOp, ops::GroupNormGradInplaceInToOut); diff --git a/paddle/fluid/operators/gru_op.cc b/paddle/fluid/operators/gru_op.cc index 9797160c9622671a820e2b9872305745df176979..4be1c3e5861dfc46fa077a864413952745ee027b 100644 --- a/paddle/fluid/operators/gru_op.cc +++ b/paddle/fluid/operators/gru_op.cc @@ -380,8 +380,10 @@ class GRUCPUKernel : public framework::OpKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(gru, ops::GRUOp, ops::GRUOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + gru, ops::GRUOp, ops::GRUOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker) REGISTER_OPERATOR(gru_grad, ops::GRUGradOp); REGISTER_OP_CPU_KERNEL(gru, ops::GRUCPUKernel, ops::GRUCPUKernel); diff --git a/paddle/fluid/operators/gru_unit_op.cc b/paddle/fluid/operators/gru_unit_op.cc index e3beedcf10b6286c92371c48cae7912aef35e7a3..ddb6588ab99f409861cb60598c8c0164230713c8 100644 --- a/paddle/fluid/operators/gru_unit_op.cc +++ b/paddle/fluid/operators/gru_unit_op.cc @@ -13,6 +13,7 @@ See the License for the specific language governing permissions and limitations under the License. */ #include "paddle/fluid/operators/gru_unit_op.h" +#include namespace paddle { namespace operators { @@ -200,33 +201,34 @@ class GRUUnitGradOp : public framework::OperatorWithKernel { } }; -class GRUUnitGradOpMaker : public framework::SingleGradOpDescMaker { +template +class GRUUnitGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("gru_unit_grad"); - op->SetInput("Input", Input("Input")); - op->SetInput("HiddenPrev", Input("HiddenPrev")); - op->SetInput("Weight", Input("Weight")); - op->SetInput("Bias", Input("Bias")); + op->SetInput("Input", this->Input("Input")); + op->SetInput("HiddenPrev", this->Input("HiddenPrev")); + op->SetInput("Weight", this->Input("Weight")); + op->SetInput("Bias", this->Input("Bias")); - op->SetInput("Hidden", Output("Hidden")); - op->SetInput("Gate", Output("Gate")); - op->SetInput("ResetHiddenPrev", Output("ResetHiddenPrev")); - op->SetInput(framework::GradVarName("Hidden"), OutputGrad("Hidden")); + op->SetInput("Hidden", this->Output("Hidden")); + op->SetInput("Gate", this->Output("Gate")); + op->SetInput("ResetHiddenPrev", this->Output("ResetHiddenPrev")); + op->SetInput(framework::GradVarName("Hidden"), this->OutputGrad("Hidden")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput(framework::GradVarName("Input"), InputGrad("Input")); + op->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input")); op->SetOutput(framework::GradVarName("HiddenPrev"), - InputGrad("HiddenPrev")); - op->SetOutput(framework::GradVarName("Weight"), InputGrad("Weight")); - op->SetOutput(framework::GradVarName("Bias"), InputGrad("Bias")); - return std::unique_ptr(op); + this->InputGrad("HiddenPrev")); + op->SetOutput(framework::GradVarName("Weight"), this->InputGrad("Weight")); + op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); + return std::unique_ptr(op); } }; @@ -236,7 +238,8 @@ class GRUUnitGradOpMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(gru_unit, ops::GRUUnitOp, ops::GRUUnitOpMaker, - ops::GRUUnitGradOpMaker); + ops::GRUUnitGradOpMaker, + ops::GRUUnitGradOpMaker); REGISTER_OPERATOR(gru_unit_grad, ops::GRUUnitGradOp); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/hierarchical_sigmoid_op.cc b/paddle/fluid/operators/hierarchical_sigmoid_op.cc index a27fcf628cc63f483a7313253fda019c6ca54e5c..a54d52ae45e8afceea80ff486831544f033de87d 100644 --- a/paddle/fluid/operators/hierarchical_sigmoid_op.cc +++ b/paddle/fluid/operators/hierarchical_sigmoid_op.cc @@ -170,30 +170,31 @@ Hierarchical Probabilistic Neural Network Language Model." * Inputs: X, W, Label, PathTable, PathCode, PreOut, Out@GRAD * Outputs: X@GRAD, W@GRAD, Bias@GRAD */ -class HierarchicalSigmoidGradMaker : public framework::SingleGradOpDescMaker { +template +class HierarchicalSigmoidGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType(this->ForwardOpType() + "_grad"); // Inputs: X, W, Label, PathTable, PathCode, PreOut, Out@GRAD - op->SetInput("X", Input("X")); - op->SetInput("W", Input("W")); - op->SetInput("Bias", Input("Bias")); - op->SetInput("Label", Input("Label")); - op->SetInput("PathTable", Input("PathTable")); - op->SetInput("PathCode", Input("PathCode")); - op->SetInput("PreOut", Output("PreOut")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); + op->SetInput("X", this->Input("X")); + op->SetInput("W", this->Input("W")); + op->SetInput("Bias", this->Input("Bias")); + op->SetInput("Label", this->Input("Label")); + op->SetInput("PathTable", this->Input("PathTable")); + op->SetInput("PathCode", this->Input("PathCode")); + op->SetInput("PreOut", this->Output("PreOut")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); // Outputs: X@GRAD, W@GRAD, Bias@GRAD - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("W"), InputGrad("W")); - op->SetOutput(framework::GradVarName("Bias"), InputGrad("Bias")); - op->SetAttrMap(Attrs()); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("W"), this->InputGrad("W")); + op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); + op->SetAttrMap(this->Attrs()); - return std::unique_ptr(op); + return std::unique_ptr(op); } }; @@ -265,9 +266,11 @@ class HierarchicalSigmoidGradOpGradVarTypeInference } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(hierarchical_sigmoid, ops::HierarchicalSigmoidOp, - ops::HierarchicalSigmoidOpMaker, - ops::HierarchicalSigmoidGradMaker); +REGISTER_OPERATOR( + hierarchical_sigmoid, ops::HierarchicalSigmoidOp, + ops::HierarchicalSigmoidOpMaker, + ops::HierarchicalSigmoidGradMaker, + ops::HierarchicalSigmoidGradMaker); REGISTER_OPERATOR(hierarchical_sigmoid_grad, ops::HierarchicalSigmoidGradOp, ops::HierarchicalSigmoidGradOpGradVarTypeInference); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/hinge_loss_op.cc b/paddle/fluid/operators/hinge_loss_op.cc index b6cfa9cc43c312e60a1b7c5e13d1ecbe6bc5dc7d..e19a39cc82cc0eaaaa7356f252f685d8854966d7 100644 --- a/paddle/fluid/operators/hinge_loss_op.cc +++ b/paddle/fluid/operators/hinge_loss_op.cc @@ -100,19 +100,20 @@ class HingeLossGradOp : public framework::OperatorWithKernel { } }; -class HingeLossGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class HingeLossGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("hinge_loss_grad"); - op->SetInput("Logits", Input("Logits")); - op->SetInput("Labels", Input("Labels")); - op->SetInput(framework::GradVarName("Loss"), OutputGrad("Loss")); - op->SetOutput(framework::GradVarName("Logits"), InputGrad("Logits")); - op->SetAttrMap(Attrs()); + op->SetInput("Logits", this->Input("Logits")); + op->SetInput("Labels", this->Input("Labels")); + op->SetInput(framework::GradVarName("Loss"), this->OutputGrad("Loss")); + op->SetOutput(framework::GradVarName("Logits"), this->InputGrad("Logits")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -122,7 +123,8 @@ class HingeLossGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(hinge_loss, ops::HingeLossOp, ops::HingeLossOpMaker, - ops::HingeLossGradOpDescMaker); + ops::HingeLossGradOpMaker, + ops::HingeLossGradOpMaker); REGISTER_OPERATOR(hinge_loss_grad, ops::HingeLossGradOp); REGISTER_OP_CPU_KERNEL( hinge_loss, diff --git a/paddle/fluid/operators/huber_loss_op.cc b/paddle/fluid/operators/huber_loss_op.cc index 9b9a5207531332d5c6f61b75d6f5952e091143d4..39cf56f7c0fc4a3af1fc74da0d6795b16289b699 100644 --- a/paddle/fluid/operators/huber_loss_op.cc +++ b/paddle/fluid/operators/huber_loss_op.cc @@ -115,19 +115,20 @@ class HuberLossGradOp : public framework::OperatorWithKernel { } }; -class HuberLossGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class HuberLossGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("huber_loss_grad"); - op->SetInput("Residual", Output("Residual")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); - op->SetAttrMap(Attrs()); + op->SetInput("Residual", this->Output("Residual")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -137,7 +138,8 @@ class HuberLossGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(huber_loss, ops::HuberLossOp, ops::HuberLossOpMaker, - ops::HuberLossGradOpDescMaker); + ops::HuberLossGradOpMaker, + ops::HuberLossGradOpMaker); REGISTER_OPERATOR(huber_loss_grad, ops::HuberLossGradOp); REGISTER_OP_CPU_KERNEL( huber_loss, ops::HuberLossKernel, diff --git a/paddle/fluid/operators/im2sequence_op.cc b/paddle/fluid/operators/im2sequence_op.cc index 0fa7322fbd65c85f574c18f822e2c189c8f87646..e3ee551c5ceab7de6941f6bf27a10a69c67fa0b8 100644 --- a/paddle/fluid/operators/im2sequence_op.cc +++ b/paddle/fluid/operators/im2sequence_op.cc @@ -147,18 +147,19 @@ class Im2SequenceGradOp : public framework::OperatorWithKernel { } }; -class Im2SequenceGradDescMaker : public framework::SingleGradOpDescMaker { +template +class Im2SequenceGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("im2sequence_grad"); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -168,7 +169,8 @@ class Im2SequenceGradDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(im2sequence, ops::Im2SequenceOp, ops::Im2SequenceOpMaker, - ops::Im2SequenceGradDescMaker); + ops::Im2SequenceGradMaker, + ops::Im2SequenceGradMaker); REGISTER_OPERATOR(im2sequence_grad, ops::Im2SequenceGradOp); REGISTER_OP_CPU_KERNEL( im2sequence, diff --git a/paddle/fluid/operators/increment_op.cc b/paddle/fluid/operators/increment_op.cc index f0ffc9706689f5afe4546c3483114b38bc2b7872..2d68965afaeabce5f34f0c74c8fd95159624f593 100644 --- a/paddle/fluid/operators/increment_op.cc +++ b/paddle/fluid/operators/increment_op.cc @@ -13,6 +13,7 @@ // limitations under the License. #include "paddle/fluid/operators/increment_op.h" +#include #include namespace paddle { @@ -65,17 +66,18 @@ $$Out = X + step$$ } }; -class IncrementGradOpMaker : public framework::SingleGradOpDescMaker { +template +class IncrementGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("increment"); - grad_op->SetInput("X", Output("Out")); - grad_op->SetOutput("Out", Input("X")); - grad_op->SetAttr("step", -boost::get(GetAttr("step"))); - return std::unique_ptr(grad_op); + grad_op->SetInput("X", this->Output("Out")); + grad_op->SetOutput("Out", this->Input("X")); + grad_op->SetAttr("step", -boost::get(this->GetAttr("step"))); + return std::unique_ptr(grad_op); } }; @@ -84,7 +86,8 @@ class IncrementGradOpMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(increment, ops::IncrementOp, ops::IncrementOpMaker, - ops::IncrementGradOpMaker); + ops::IncrementGradOpMaker, + ops::IncrementGradOpMaker); REGISTER_OP_CPU_KERNEL( increment, ops::IncrementKernel, ops::IncrementKernel, diff --git a/paddle/fluid/operators/instance_norm_op.cc b/paddle/fluid/operators/instance_norm_op.cc index bb6b37e64e4ed0a4d683d69397416d1ef468102a..a67044849c7d69b4e178213f980d6430e031d7e1 100644 --- a/paddle/fluid/operators/instance_norm_op.cc +++ b/paddle/fluid/operators/instance_norm_op.cc @@ -331,25 +331,6 @@ class InstanceNormGradKernel } }; -std::unique_ptr InstanceNormGradMaker::Apply() const { - auto *op = new framework::OpDesc(); - op->SetType("instance_norm_grad"); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - - op->SetInput("Scale", Input("Scale")); - op->SetInput("Bias", Input("Bias")); - op->SetInput("SavedMean", Output("SavedMean")); - op->SetInput("SavedVariance", Output("SavedVariance")); - - op->SetAttrMap(Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Scale"), InputGrad("Scale")); - op->SetOutput(framework::GradVarName("Bias"), InputGrad("Bias")); - - return std::unique_ptr(op); -} - void InstanceNormDoubleGradOp::InferShape( framework::InferShapeContext *ctx) const { PADDLE_ENFORCE_EQ(ctx->HasInput("X"), true, "Input(X) should not be null"); @@ -400,25 +381,6 @@ framework::OpKernelType InstanceNormDoubleGradOp::GetExpectedKernelType( OperatorWithKernel::IndicateVarDataType(ctx, "X"), ctx.GetPlace()); } -std::unique_ptr InstanceNormDoubleGradMaker::Apply() const { - auto *op = new framework::OpDesc(); - op->SetType("instance_norm_grad_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Scale", Input("Scale")); - op->SetInput("SavedMean", Input("SavedMean")); - op->SetInput("SavedVariance", Input("SavedVariance")); - op->SetInput("DDX", OutputGrad(framework::GradVarName("X"))); - op->SetInput("DDScale", OutputGrad(framework::GradVarName("Scale"))); - op->SetInput("DDBias", OutputGrad(framework::GradVarName("Bias"))); - op->SetInput("DY", Input(framework::GradVarName("Y"))); - - op->SetAttrMap(Attrs()); - op->SetOutput("DX", InputGrad("X")); - op->SetOutput("DScale", InputGrad("Scale")); - op->SetOutput("DDY", InputGrad(framework::GradVarName("Y"))); - return std::unique_ptr(op); -} - template class InstanceNormDoubleGradKernel : public framework::OpKernel { @@ -624,9 +586,12 @@ DECLARE_INPLACE_OP_INFERER(InstanceNormDoubleGradOpInplaceInference, namespace ops = paddle::operators; REGISTER_OPERATOR(instance_norm, ops::InstanceNormOp, ops::InstanceNormOpMaker, - ops::InstanceNormOpInferVarType, ops::InstanceNormGradMaker); + ops::InstanceNormOpInferVarType, + ops::InstanceNormGradMaker, + ops::InstanceNormGradMaker); REGISTER_OPERATOR(instance_norm_grad, ops::InstanceNormGradOp, - ops::InstanceNormDoubleGradMaker); + ops::InstanceNormDoubleGradMaker, + ops::InstanceNormDoubleGradMaker); REGISTER_OPERATOR(instance_norm_grad_grad, ops::InstanceNormDoubleGradOp, ops::InstanceNormDoubleGradOpInplaceInference); diff --git a/paddle/fluid/operators/instance_norm_op.h b/paddle/fluid/operators/instance_norm_op.h index 509c1ff038d1f2169bc54bbdef5f8dc210a78120..9ff6f09ad0121a8d7ff64d5bfa6705e7a2813fb6 100644 --- a/paddle/fluid/operators/instance_norm_op.h +++ b/paddle/fluid/operators/instance_norm_op.h @@ -74,20 +74,56 @@ class InstanceNormOpMaker : public framework::OpProtoAndCheckerMaker { void Make() override; }; -class InstanceNormGradMaker : public framework::SingleGradOpDescMaker { +template +class InstanceNormGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override; + std::unique_ptr Apply() const override { + auto *op = new T(); + op->SetType("instance_norm_grad"); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + + op->SetInput("Scale", this->Input("Scale")); + op->SetInput("Bias", this->Input("Bias")); + op->SetInput("SavedMean", this->Output("SavedMean")); + op->SetInput("SavedVariance", this->Output("SavedVariance")); + + op->SetAttrMap(this->Attrs()); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Scale"), this->InputGrad("Scale")); + op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); + + return std::unique_ptr(op); + } }; -class InstanceNormDoubleGradMaker : public framework::SingleGradOpDescMaker { +template +class InstanceNormDoubleGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override; + std::unique_ptr Apply() const override { + auto *op = new T(); + op->SetType("instance_norm_grad_grad"); + op->SetInput("X", this->Input("X")); + op->SetInput("Scale", this->Input("Scale")); + op->SetInput("SavedMean", this->Input("SavedMean")); + op->SetInput("SavedVariance", this->Input("SavedVariance")); + op->SetInput("DDX", this->OutputGrad(framework::GradVarName("X"))); + op->SetInput("DDScale", this->OutputGrad(framework::GradVarName("Scale"))); + op->SetInput("DDBias", this->OutputGrad(framework::GradVarName("Bias"))); + op->SetInput("DY", this->Input(framework::GradVarName("Y"))); + + op->SetAttrMap(this->Attrs()); + op->SetOutput("DX", this->InputGrad("X")); + op->SetOutput("DScale", this->InputGrad("Scale")); + op->SetOutput("DDY", this->InputGrad(framework::GradVarName("Y"))); + return std::unique_ptr(op); + } }; class InstanceNormOpInferVarType diff --git a/paddle/fluid/operators/interpolate_op.cc b/paddle/fluid/operators/interpolate_op.cc index cbe9865673b0efd2080157d7562d635fdea51922..cc753b1f91fd851514b21bdb260a569fa4576af5 100644 --- a/paddle/fluid/operators/interpolate_op.cc +++ b/paddle/fluid/operators/interpolate_op.cc @@ -423,27 +423,28 @@ class InterpolateOpGrad : public framework::OperatorWithKernel { } }; -class InterpolateGradDescMaker : public framework::SingleGradOpDescMaker { +template +class InterpolateGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); - op->SetType(ForwardOp().Type() + "_grad"); - op->SetInput("X", Input("X")); - if (ForwardOp().Inputs().count("SizeTensor") > 0) { - op->SetInput("SizeTensor", Input("SizeTensor")); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); + op->SetType(this->ForwardOpType() + "_grad"); + op->SetInput("X", this->Input("X")); + if (this->HasInput("SizeTensor") > 0) { + op->SetInput("SizeTensor", this->Input("SizeTensor")); } - if (ForwardOp().Inputs().count("OutSize") > 0) { - op->SetInput("OutSize", Input("OutSize")); + if (this->HasInput("OutSize") > 0) { + op->SetInput("OutSize", this->Input("OutSize")); } - if (ForwardOp().Inputs().count("Scale") > 0) { - op->SetInput("Scale", Input("Scale")); + if (this->HasInput("Scale") > 0) { + op->SetInput("Scale", this->Input("Scale")); } - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -456,15 +457,18 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(InterpolateGradNoNeedBufferVarsInference, namespace ops = paddle::operators; REGISTER_OPERATOR(bilinear_interp, ops::InterpolateOp, ops::InterpolateOpMaker, - ops::InterpolateGradDescMaker); + ops::InterpolateGradMaker, + ops::InterpolateGradMaker); REGISTER_OPERATOR(bilinear_interp_grad, ops::InterpolateOpGrad, ops::InterpolateGradNoNeedBufferVarsInference); REGISTER_OPERATOR(nearest_interp, ops::InterpolateOp, ops::InterpolateOpMaker, - ops::InterpolateGradDescMaker); + ops::InterpolateGradMaker, + ops::InterpolateGradMaker); REGISTER_OPERATOR(nearest_interp_grad, ops::InterpolateOpGrad, ops::InterpolateGradNoNeedBufferVarsInference); REGISTER_OPERATOR(trilinear_interp, ops::InterpolateOp, ops::InterpolateOpMaker, - ops::InterpolateGradDescMaker); + ops::InterpolateGradMaker, + ops::InterpolateGradMaker); REGISTER_OPERATOR(trilinear_interp_grad, ops::InterpolateOpGrad, ops::InterpolateGradNoNeedBufferVarsInference); REGISTER_OP_CPU_KERNEL(bilinear_interp, ops::InterpolateKernel, diff --git a/paddle/fluid/operators/is_empty_op.cc b/paddle/fluid/operators/is_empty_op.cc index 109e96fb7baa26c25087819c54c21d14b602d2cb..1f78675060ecb4335261f96ba0c36ba16aa1f052 100644 --- a/paddle/fluid/operators/is_empty_op.cc +++ b/paddle/fluid/operators/is_empty_op.cc @@ -58,8 +58,10 @@ It will just return product(tensor.ddims()) > 0; } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(is_empty, ops::IsEmptyOp, ops::IsEmptyOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + is_empty, ops::IsEmptyOp, ops::IsEmptyOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( is_empty, ops::IsEmptyOpKernel, ops::IsEmptyOpKernel, diff --git a/paddle/fluid/operators/isfinite_op.cc b/paddle/fluid/operators/isfinite_op.cc index 1312eecfa4466755b0e6ff3cf153a807276bfd1f..f8c584163fbef040a96d696e5da07095854f1cc3 100644 --- a/paddle/fluid/operators/isfinite_op.cc +++ b/paddle/fluid/operators/isfinite_op.cc @@ -84,20 +84,21 @@ If X contains both Inf/Nan, it will return the first indicator it meeted. namespace ops = paddle::operators; -#define REGISTER_OP_MAKER(op_type, comment) \ - namespace paddle { \ - namespace operators { \ - class _##op_type##OverflowOpMaker \ - : public ::paddle::operators::OverflowOpMaker { \ - protected: \ - std::string GetName() const { return #op_type; } \ - std::string GetComments() const { return comment; } \ - }; \ - } \ - } \ - REGISTER_OPERATOR(op_type, ops::OverflowOp, \ - ops::_##op_type##OverflowOpMaker, \ - paddle::framework::EmptyGradOpMaker) +#define REGISTER_OP_MAKER(op_type, comment) \ + namespace paddle { \ + namespace operators { \ + class _##op_type##OverflowOpMaker \ + : public ::paddle::operators::OverflowOpMaker { \ + protected: \ + std::string GetName() const { return #op_type; } \ + std::string GetComments() const { return comment; } \ + }; \ + } \ + } \ + REGISTER_OPERATOR( \ + op_type, ops::OverflowOp, ops::_##op_type##OverflowOpMaker, \ + paddle::framework::EmptyGradOpMaker, \ + paddle::framework::EmptyGradOpMaker) #define REGISTER_OVERFLOW_CPU_KERNEL(op_type, functor) \ REGISTER_OP_CPU_KERNEL( \ diff --git a/paddle/fluid/operators/kldiv_loss_op.cc b/paddle/fluid/operators/kldiv_loss_op.cc index d5976e7f4ae2240722f58d2348503a75692ff553..8492ac915b88508be1e5b1d13263e62e42bf5374 100644 --- a/paddle/fluid/operators/kldiv_loss_op.cc +++ b/paddle/fluid/operators/kldiv_loss_op.cc @@ -141,22 +141,23 @@ class KLDivLossOpGrad : public framework::OperatorWithKernel { } }; -class KLDivLossOpGradMaker : public framework::SingleGradOpDescMaker { +template +class KLDivLossOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("kldiv_loss_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Target", Input("Target")); - op->SetInput(framework::GradVarName("Loss"), OutputGrad("Loss")); + op->SetInput("X", this->Input("X")); + op->SetInput("Target", this->Input("Target")); + op->SetInput(framework::GradVarName("Loss"), this->OutputGrad("Loss")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - return std::unique_ptr(op); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + return std::unique_ptr(op); } }; @@ -165,7 +166,8 @@ class KLDivLossOpGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(kldiv_loss, ops::KLDivLossOp, ops::KLDivLossOpMaker, - ops::KLDivLossOpGradMaker); + ops::KLDivLossOpGradMaker, + ops::KLDivLossOpGradMaker); REGISTER_OPERATOR(kldiv_loss_grad, ops::KLDivLossOpGrad); REGISTER_OP_CPU_KERNEL( kldiv_loss, ops::KLDivLossKernel, diff --git a/paddle/fluid/operators/l1_norm_op.cc b/paddle/fluid/operators/l1_norm_op.cc index 2696d0bef9e322fce1251984c9e0f5b7429eeea8..12fd07f6de71c50efc4cb53c1ba7047527ed9fee 100644 --- a/paddle/fluid/operators/l1_norm_op.cc +++ b/paddle/fluid/operators/l1_norm_op.cc @@ -63,18 +63,19 @@ $$Out = \sum{|X|}$$ } }; -class L1NormGradDescMaker : public framework::SingleGradOpDescMaker { +template +class L1NormGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("l1_norm_grad"); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -84,7 +85,8 @@ class L1NormGradDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(l1_norm, ops::L1NormOp, ops::L1NormOpMaker, - ops::L1NormGradDescMaker); + ops::L1NormGradMaker, + ops::L1NormGradMaker); REGISTER_OPERATOR(l1_norm_grad, ops::L1NormGradOp); REGISTER_OP_CPU_KERNEL( l1_norm, ops::L1NormKernel); diff --git a/paddle/fluid/operators/label_smooth_op.cc b/paddle/fluid/operators/label_smooth_op.cc index 6d0af573184b10a783f9c5802d1db3630eb55538..b76ccbcfce09e1aea933f0a909530f4fd5e22a3e 100644 --- a/paddle/fluid/operators/label_smooth_op.cc +++ b/paddle/fluid/operators/label_smooth_op.cc @@ -111,17 +111,18 @@ class LabelSmoothGradOp : public framework::OperatorWithKernel { } }; -class LabelSmoothGradDescMaker : public framework::SingleGradOpDescMaker { +template +class LabelSmoothGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("label_smooth_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -131,7 +132,8 @@ class LabelSmoothGradDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(label_smooth, ops::LabelSmoothOp, ops::LabelSmoothOpMaker, - ops::LabelSmoothGradDescMaker); + ops::LabelSmoothGradMaker, + ops::LabelSmoothGradMaker); REGISTER_OPERATOR(label_smooth_grad, ops::LabelSmoothGradOp); REGISTER_OP_CPU_KERNEL( label_smooth, diff --git a/paddle/fluid/operators/layer_norm_op.cc b/paddle/fluid/operators/layer_norm_op.cc index 1aac60ef36c62703f8f9a3b896c17a1483642f53..3e77f0922b435aa41cc97121273d82381df738d5 100644 --- a/paddle/fluid/operators/layer_norm_op.cc +++ b/paddle/fluid/operators/layer_norm_op.cc @@ -165,29 +165,30 @@ class LayerNormGradOp : public framework::OperatorWithKernel { } }; -class LayerNormGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class LayerNormGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("layer_norm_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Mean", Output("Mean")); - op->SetInput("Variance", Output("Variance")); - if (ForwardOp().Inputs().count("Scale") > 0) { - op->SetInput("Scale", Input("Scale")); - op->SetOutput(framework::GradVarName("Scale"), InputGrad("Scale")); + op->SetInput("X", this->Input("X")); + op->SetInput("Mean", this->Output("Mean")); + op->SetInput("Variance", this->Output("Variance")); + if (this->HasInput("Scale")) { + op->SetInput("Scale", this->Input("Scale")); + op->SetOutput(framework::GradVarName("Scale"), this->InputGrad("Scale")); } - if (ForwardOp().Inputs().count("Bias") > 0) { - op->SetOutput(framework::GradVarName("Bias"), InputGrad("Bias")); + if (this->HasInput("Bias")) { + op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); } - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -197,7 +198,8 @@ class LayerNormGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(layer_norm, ops::LayerNormOp, ops::LayerNormOpMaker, - ops::LayerNormGradOpDescMaker); + ops::LayerNormGradOpMaker, + ops::LayerNormGradOpMaker); REGISTER_OPERATOR(layer_norm_grad, ops::LayerNormGradOp); REGISTER_OP_CPU_KERNEL( layer_norm, ops::LayerNormKernel, diff --git a/paddle/fluid/operators/linear_chain_crf_op.cc b/paddle/fluid/operators/linear_chain_crf_op.cc index 32d9f09e3a26ec01d33a52746fe1d45b81e39ee7..a0b803238e478b76879f4cbb79cce007e94e72cb 100644 --- a/paddle/fluid/operators/linear_chain_crf_op.cc +++ b/paddle/fluid/operators/linear_chain_crf_op.cc @@ -274,30 +274,32 @@ class LinearChainCRFGradOp : public framework::OperatorWithKernel { } }; -class LinearChainCRFGradDescMaker : public framework::SingleGradOpDescMaker { +template +class LinearChainCRFGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("linear_chain_crf_grad"); - op->SetAttrMap(Attrs()); - op->SetInput("Emission", Input("Emission")); - op->SetInput("Transition", Input("Transition")); - op->SetInput("Label", Input("Label")); - op->SetInput("Alpha", Output("Alpha")); - op->SetInput("EmissionExps", Output("EmissionExps")); - op->SetInput("TransitionExps", Output("TransitionExps")); - if (ForwardOp().Inputs().count("Length") > 0) { - op->SetInput("Length", Input("Length")); + op->SetAttrMap(this->Attrs()); + op->SetInput("Emission", this->Input("Emission")); + op->SetInput("Transition", this->Input("Transition")); + op->SetInput("Label", this->Input("Label")); + op->SetInput("Alpha", this->Output("Alpha")); + op->SetInput("EmissionExps", this->Output("EmissionExps")); + op->SetInput("TransitionExps", this->Output("TransitionExps")); + if (this->HasInput("Length")) { + op->SetInput("Length", this->Input("Length")); } op->SetInput(framework::GradVarName("LogLikelihood"), - OutputGrad("LogLikelihood")); + this->OutputGrad("LogLikelihood")); - op->SetOutput(framework::GradVarName("Emission"), InputGrad("Emission")); + op->SetOutput(framework::GradVarName("Emission"), + this->InputGrad("Emission")); op->SetOutput(framework::GradVarName("Transition"), - InputGrad("Transition")); + this->InputGrad("Transition")); return op; } @@ -311,7 +313,9 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE( namespace ops = paddle::operators; REGISTER_OPERATOR(linear_chain_crf, ops::LinearChainCRFOp, - ops::LinearChainCRFOpMaker, ops::LinearChainCRFGradDescMaker); + ops::LinearChainCRFOpMaker, + ops::LinearChainCRFGradMaker, + ops::LinearChainCRFGradMaker); REGISTER_OPERATOR(linear_chain_crf_grad, ops::LinearChainCRFGradOp, ops::LinearChainCRFGradNoNeedBufferVarsInference); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/lod_array_length_op.cc b/paddle/fluid/operators/lod_array_length_op.cc index e4551b8ba681fe92ac5f21bb0b509f43439f6b66..2553b9fb22793ebfc2eda5f8f6783357de179ffb 100644 --- a/paddle/fluid/operators/lod_array_length_op.cc +++ b/paddle/fluid/operators/lod_array_length_op.cc @@ -70,6 +70,8 @@ class LoDArrayLengthInferShape : public framework::InferShapeBase { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(lod_array_length, ops::LoDArrayLengthOp, - ops::LoDArrayLengthInferShape, ops::LoDArrayLengthProtoMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + lod_array_length, ops::LoDArrayLengthOp, ops::LoDArrayLengthInferShape, + ops::LoDArrayLengthProtoMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/lod_rank_table_op.cc b/paddle/fluid/operators/lod_rank_table_op.cc index 0a43ac0c52f9bc98eacf743480166682482cc3c0..8e16834e8435a30f77d5e1dd19a53b5436490d01 100644 --- a/paddle/fluid/operators/lod_rank_table_op.cc +++ b/paddle/fluid/operators/lod_rank_table_op.cc @@ -74,8 +74,10 @@ class LoDRankTableInferVarType : public framework::VarTypeInference { } // namespace operators } // namespace paddle -REGISTER_OPERATOR(lod_rank_table, paddle::operators::LoDRankTableOp, - paddle::operators::LoDRankTableOpProtoMaker, - paddle::operators::LoDRankTableInferShape, - paddle::operators::LoDRankTableInferVarType, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + lod_rank_table, paddle::operators::LoDRankTableOp, + paddle::operators::LoDRankTableOpProtoMaker, + paddle::operators::LoDRankTableInferShape, + paddle::operators::LoDRankTableInferVarType, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/lod_reset_op.cc b/paddle/fluid/operators/lod_reset_op.cc index 190a7cdf12faf4ae38eb1f3c1a777c4621dbeace..baa709b9e493095f2bc310e0f07ad3fd39718c70 100644 --- a/paddle/fluid/operators/lod_reset_op.cc +++ b/paddle/fluid/operators/lod_reset_op.cc @@ -179,18 +179,19 @@ class LoDResetGradOp : public framework::OperatorWithKernel { } }; -class LoDResetGradDescMaker : public framework::SingleGradOpDescMaker { +template +class LoDResetGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("lod_reset_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput("X", Input("X")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput("X", this->Input("X")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -203,7 +204,9 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(LoDResetGradNoNeedBufferVarInference, namespace ops = paddle::operators; REGISTER_OPERATOR(lod_reset, ops::LoDResetOp, ops::LoDResetOpMaker, - ops::LoDResetGradDescMaker, ops::LoDResetOpVarTypeInference); + ops::LoDResetGradMaker, + ops::LoDResetGradMaker, + ops::LoDResetOpVarTypeInference); REGISTER_OPERATOR(lod_reset_grad, ops::LoDResetGradOp, ops::LoDResetGradNoNeedBufferVarInference); diff --git a/paddle/fluid/operators/lod_tensor_to_array_op.cc b/paddle/fluid/operators/lod_tensor_to_array_op.cc index 9480f0b25113d24d244018692462f1dd02448213..fbabd3583064ac9b203ebdc669fe6492be48c8d4 100644 --- a/paddle/fluid/operators/lod_tensor_to_array_op.cc +++ b/paddle/fluid/operators/lod_tensor_to_array_op.cc @@ -226,19 +226,20 @@ class LoDTensorToArrayInferVarType : public framework::VarTypeInference { } }; -class LoDTensorToArrayGradMaker : public framework::SingleGradOpDescMaker { +template +class LoDTensorToArrayGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("array_to_lod_tensor"); - grad_op->SetInput("X", OutputGrad("Out")); - grad_op->SetInput("RankTable", Input("RankTable")); - grad_op->SetOutput("Out", InputGrad("X")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("X", this->OutputGrad("Out")); + grad_op->SetInput("RankTable", this->Input("RankTable")); + grad_op->SetOutput("Out", this->InputGrad("X")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -250,4 +251,5 @@ REGISTER_OPERATOR(lod_tensor_to_array, ops::LoDTensorToArrayOp, ops::LoDTensorToArrayOpProtoMaker, ops::LoDTensorToArrayInferShape, ops::LoDTensorToArrayInferVarType, - ops::LoDTensorToArrayGradMaker); + ops::LoDTensorToArrayGradMaker, + ops::LoDTensorToArrayGradMaker); diff --git a/paddle/fluid/operators/log_loss_op.cc b/paddle/fluid/operators/log_loss_op.cc index 0048c75ccf04687b42f990dc5aa79541359645c1..caea24022c418358798c951f5370c7d7af5fef72 100644 --- a/paddle/fluid/operators/log_loss_op.cc +++ b/paddle/fluid/operators/log_loss_op.cc @@ -105,19 +105,21 @@ class LogLossGradOp : public framework::OperatorWithKernel { } }; -class LogLossGradDescMaker : public framework::SingleGradOpDescMaker { +template +class LogLossGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("log_loss_grad"); - op->SetInput("Predicted", Input("Predicted")); - op->SetInput("Labels", Input("Labels")); - op->SetInput(framework::GradVarName("Loss"), OutputGrad("Loss")); - op->SetOutput(framework::GradVarName("Predicted"), InputGrad("Predicted")); - op->SetAttrMap(Attrs()); + op->SetInput("Predicted", this->Input("Predicted")); + op->SetInput("Labels", this->Input("Labels")); + op->SetInput(framework::GradVarName("Loss"), this->OutputGrad("Loss")); + op->SetOutput(framework::GradVarName("Predicted"), + this->InputGrad("Predicted")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -127,7 +129,8 @@ class LogLossGradDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(log_loss, ops::LogLossOp, ops::LogLossOpMaker, - ops::LogLossGradDescMaker); + ops::LogLossGradMaker, + ops::LogLossGradMaker); REGISTER_OPERATOR(log_loss_grad, ops::LogLossGradOp); REGISTER_OP_CPU_KERNEL( log_loss, ops::LogLossKernel); diff --git a/paddle/fluid/operators/lookup_sparse_table_op.cc b/paddle/fluid/operators/lookup_sparse_table_op.cc index 4840a7ac1e79840f314cb40365d25332a1292c46..ef3030d9be2b14fcb09fac43ba43e81e525f6f46 100644 --- a/paddle/fluid/operators/lookup_sparse_table_op.cc +++ b/paddle/fluid/operators/lookup_sparse_table_op.cc @@ -114,7 +114,8 @@ random value and set the value into the table for the next looking up. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(lookup_sparse_table, ops::LookupSparseTableOp, - ops::LookupSparseTableInferShape, - ops::LookupSparseTableOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + lookup_sparse_table, ops::LookupSparseTableOp, + ops::LookupSparseTableInferShape, ops::LookupSparseTableOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/lookup_table_op.cc b/paddle/fluid/operators/lookup_table_op.cc index c1d45bb7a0d1e57d1bf6fb06d42d63d074fea200..feed5a65d6b20f4dc066d4b6e76823bc853649bd 100644 --- a/paddle/fluid/operators/lookup_table_op.cc +++ b/paddle/fluid/operators/lookup_table_op.cc @@ -133,23 +133,24 @@ or not. And the output only shares the LoD information with input Ids. DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(LookupTableGradOpNoBuffer, "W"); -class LookupTableGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class LookupTableGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("lookup_table_grad"); - op->SetInput("W", Input("W")); - op->SetInput("Ids", Input("Ids")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); + op->SetInput("W", this->Input("W")); + op->SetInput("Ids", this->Input("Ids")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); - op->SetOutput(framework::GradVarName("W"), InputGrad("W")); + op->SetOutput(framework::GradVarName("W"), this->InputGrad("W")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -196,7 +197,8 @@ class LookupTableOpGradVarTypeInference : public framework::VarTypeInference { namespace ops = paddle::operators; REGISTER_OPERATOR(lookup_table, ops::LookupTableOp, ops::LookupTableOpMaker, - ops::LookupTableGradOpDescMaker); + ops::LookupTableGradOpMaker, + ops::LookupTableGradOpMaker); REGISTER_OPERATOR(lookup_table_grad, ops::LookupTableOpGrad, ops::LookupTableGradOpNoBuffer, diff --git a/paddle/fluid/operators/lookup_table_v2_op.cc b/paddle/fluid/operators/lookup_table_v2_op.cc index f0cffa4e1fe1046c580c5e2d0cecfbd7626ccd9b..4aadd4b8c0015368dcea7f0787271413bcdee172 100644 --- a/paddle/fluid/operators/lookup_table_v2_op.cc +++ b/paddle/fluid/operators/lookup_table_v2_op.cc @@ -121,23 +121,24 @@ or not. And the output only shares the LoD information with input Ids. DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(LookupTableV2GradOpNoBuffer, "W"); -class LookupTableV2GradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class LookupTableV2GradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("lookup_table_v2_grad"); - op->SetInput("W", Input("W")); - op->SetInput("Ids", Input("Ids")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); + op->SetInput("W", this->Input("W")); + op->SetInput("Ids", this->Input("Ids")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); - op->SetOutput(framework::GradVarName("W"), InputGrad("W")); + op->SetOutput(framework::GradVarName("W"), this->InputGrad("W")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -184,7 +185,9 @@ class LookupTableV2OpGradVarTypeInference : public framework::VarTypeInference { namespace ops = paddle::operators; REGISTER_OPERATOR(lookup_table_v2, ops::LookupTableV2Op, - ops::LookupTableV2OpMaker, ops::LookupTableV2GradOpDescMaker); + ops::LookupTableV2OpMaker, + ops::LookupTableV2GradOpMaker, + ops::LookupTableV2GradOpMaker); REGISTER_OPERATOR(lookup_table_v2_grad, ops::LookupTableV2OpGrad, ops::LookupTableV2GradOpNoBuffer, diff --git a/paddle/fluid/operators/lrn_op.cc b/paddle/fluid/operators/lrn_op.cc index d5b092ec99d71b12ec3b922a2bae1916d182dab1..19c33b48c1dcc1cb1a866f3ffb6e4ab50eff0907 100644 --- a/paddle/fluid/operators/lrn_op.cc +++ b/paddle/fluid/operators/lrn_op.cc @@ -294,8 +294,11 @@ class LRNOpGrad : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(lrn, ops::LRNOp, ops::LRNOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + lrn, ops::LRNOp, ops::LRNOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); + REGISTER_OPERATOR(lrn_grad, ops::LRNOpGrad); REGISTER_OP_CPU_KERNEL( lrn, ops::LRNKernel); diff --git a/paddle/fluid/operators/lstm_op.cc b/paddle/fluid/operators/lstm_op.cc index 43af877085bd06c654c26dc471eaf0d137347ab0..ef0281436e5a16a2bddcdcd7536197a3b0704705 100644 --- a/paddle/fluid/operators/lstm_op.cc +++ b/paddle/fluid/operators/lstm_op.cc @@ -267,41 +267,42 @@ class LSTMGradOp : public framework::OperatorWithKernel { } }; -class LSTMGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class LSTMGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("lstm_grad"); - op->SetAttrMap(Attrs()); - op->SetInput("Input", Input("Input")); - op->SetOutput(framework::GradVarName("Input"), InputGrad("Input")); + op->SetAttrMap(this->Attrs()); + op->SetInput("Input", this->Input("Input")); + op->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input")); - if (ForwardOp().Inputs().count("H0") > 0) { - op->SetInput("H0", Input("H0")); - op->SetOutput(framework::GradVarName("H0"), InputGrad("H0")); + if (this->HasInput("H0")) { + op->SetInput("H0", this->Input("H0")); + op->SetOutput(framework::GradVarName("H0"), this->InputGrad("H0")); } - if (ForwardOp().Inputs().count("C0") > 0) { - op->SetInput("C0", Input("C0")); - op->SetOutput(framework::GradVarName("C0"), InputGrad("C0")); + if (this->HasInput("C0")) { + op->SetInput("C0", this->Input("C0")); + op->SetOutput(framework::GradVarName("C0"), this->InputGrad("C0")); } - op->SetInput("Weight", Input("Weight")); - op->SetOutput(framework::GradVarName("Weight"), InputGrad("Weight")); + op->SetInput("Weight", this->Input("Weight")); + op->SetOutput(framework::GradVarName("Weight"), this->InputGrad("Weight")); - op->SetInput("Bias", Input("Bias")); - op->SetOutput(framework::GradVarName("Bias"), InputGrad("Bias")); + op->SetInput("Bias", this->Input("Bias")); + op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); - op->SetInput("Cell", Output("Cell")); + op->SetInput("Cell", this->Output("Cell")); - op->SetInput("Hidden", Output("Hidden")); - op->SetInput(framework::GradVarName("Hidden"), OutputGrad("Hidden")); + op->SetInput("Hidden", this->Output("Hidden")); + op->SetInput(framework::GradVarName("Hidden"), this->OutputGrad("Hidden")); - op->SetInput("BatchGate", Output("BatchGate")); - op->SetInput("BatchCellPreAct", Output("BatchCellPreAct")); + op->SetInput("BatchGate", this->Output("BatchGate")); + op->SetInput("BatchCellPreAct", this->Output("BatchCellPreAct")); return op; } }; @@ -311,7 +312,8 @@ class LSTMGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(lstm, ops::LSTMOp, ops::LSTMOpMaker, - ops::LSTMGradOpDescMaker); + ops::LSTMGradOpMaker, + ops::LSTMGradOpMaker); REGISTER_OPERATOR(lstm_grad, ops::LSTMGradOp); REGISTER_OP_CPU_KERNEL( lstm, ops::LSTMKernel, diff --git a/paddle/fluid/operators/lstm_unit_op.cc b/paddle/fluid/operators/lstm_unit_op.cc index 47d695475c2e240d273fe873352cf5c213e2026e..e3821f9dc203c08df6ff2e4cd69dd3664bb42597 100644 --- a/paddle/fluid/operators/lstm_unit_op.cc +++ b/paddle/fluid/operators/lstm_unit_op.cc @@ -98,8 +98,10 @@ class LstmUnitGradOp : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(lstm_unit, ops::LstmUnitOp, ops::LstmUnitOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + lstm_unit, ops::LstmUnitOp, ops::LstmUnitOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(lstm_unit_grad, ops::LstmUnitGradOp); REGISTER_OP_CPU_KERNEL(lstm_unit, ops::LstmUnitKernel, diff --git a/paddle/fluid/operators/lstmp_op.cc b/paddle/fluid/operators/lstmp_op.cc index 68e204983e8e54d5f9ebe46405a3a1fd7a249c04..b71735592f3d6ff84b3b79ea9829e300ed069a2d 100644 --- a/paddle/fluid/operators/lstmp_op.cc +++ b/paddle/fluid/operators/lstmp_op.cc @@ -272,39 +272,42 @@ Users can choose to use fully-connected operator before LSTMP operator. } }; -class LSTMPGradMaker : public framework::SingleGradOpDescMaker { +template +class LSTMPGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* grad_op = new T(); grad_op->SetType("lstmp_grad"); - grad_op->SetInput("Weight", Input("Weight")); - grad_op->SetInput("ProjWeight", Input("ProjWeight")); - grad_op->SetInput("Bias", Input("Bias")); - - grad_op->SetInput("Projection", Output("Projection")); - grad_op->SetInput("Cell", Output("Cell")); - grad_op->SetInput("BatchGate", Output("BatchGate")); - grad_op->SetInput("BatchCellPreAct", Output("BatchCellPreAct")); - grad_op->SetInput("BatchHidden", Output("BatchHidden")); - grad_op->SetInput("H0", Input("H0")); - grad_op->SetInput("C0", Input("C0")); + grad_op->SetInput("Weight", this->Input("Weight")); + grad_op->SetInput("ProjWeight", this->Input("ProjWeight")); + grad_op->SetInput("Bias", this->Input("Bias")); + + grad_op->SetInput("Projection", this->Output("Projection")); + grad_op->SetInput("Cell", this->Output("Cell")); + grad_op->SetInput("BatchGate", this->Output("BatchGate")); + grad_op->SetInput("BatchCellPreAct", this->Output("BatchCellPreAct")); + grad_op->SetInput("BatchHidden", this->Output("BatchHidden")); + grad_op->SetInput("H0", this->Input("H0")); + grad_op->SetInput("C0", this->Input("C0")); grad_op->SetInput(framework::GradVarName("Projection"), - OutputGrad("Projection")); + this->OutputGrad("Projection")); - grad_op->SetOutput(framework::GradVarName("Input"), InputGrad("Input")); - grad_op->SetOutput(framework::GradVarName("Weight"), InputGrad("Weight")); + grad_op->SetOutput(framework::GradVarName("Input"), + this->InputGrad("Input")); + grad_op->SetOutput(framework::GradVarName("Weight"), + this->InputGrad("Weight")); grad_op->SetOutput(framework::GradVarName("ProjWeight"), - InputGrad("ProjWeight")); - grad_op->SetOutput(framework::GradVarName("Bias"), InputGrad("Bias")); - grad_op->SetOutput(framework::GradVarName("H0"), InputGrad("H0")); - grad_op->SetOutput(framework::GradVarName("C0"), InputGrad("C0")); + this->InputGrad("ProjWeight")); + grad_op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); + grad_op->SetOutput(framework::GradVarName("H0"), this->InputGrad("H0")); + grad_op->SetOutput(framework::GradVarName("C0"), this->InputGrad("C0")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -357,7 +360,9 @@ class LSTMPGradOp : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(lstmp, ops::LSTMPOp, ops::LSTMPOpMaker, ops::LSTMPGradMaker); +REGISTER_OPERATOR(lstmp, ops::LSTMPOp, ops::LSTMPOpMaker, + ops::LSTMPGradMaker, + ops::LSTMPGradMaker); REGISTER_OPERATOR(lstmp_grad, ops::LSTMPGradOp); REGISTER_OP_CPU_KERNEL( lstmp, ops::LSTMPKernel, diff --git a/paddle/fluid/operators/margin_rank_loss_op.cc b/paddle/fluid/operators/margin_rank_loss_op.cc index fca3532551730a39bda7cfad60151de97ef881de..12ff6a9b50380bec355f71d6a29e0851fb4949cf 100644 --- a/paddle/fluid/operators/margin_rank_loss_op.cc +++ b/paddle/fluid/operators/margin_rank_loss_op.cc @@ -105,20 +105,21 @@ class MarginRankLossGradOp : public framework::OperatorWithKernel { } }; -class MarginRankLossGradDescMaker : public framework::SingleGradOpDescMaker { +template +class MarginRankLossGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("margin_rank_loss_grad"); - op->SetInput("Activated", Output("Activated")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput("Label", Input("Label")); - op->SetOutput(framework::GradVarName("X1"), InputGrad("X1")); - op->SetOutput(framework::GradVarName("X2"), InputGrad("X2")); - op->SetAttrMap(Attrs()); + op->SetInput("Activated", this->Output("Activated")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput("Label", this->Input("Label")); + op->SetOutput(framework::GradVarName("X1"), this->InputGrad("X1")); + op->SetOutput(framework::GradVarName("X2"), this->InputGrad("X2")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -129,7 +130,8 @@ namespace ops = paddle::operators; REGISTER_OPERATOR(margin_rank_loss, ops::MarginRankLossOp, ops::MarginRankLossOpMaker, - ops::MarginRankLossGradDescMaker); + ops::MarginRankLossGradMaker, + ops::MarginRankLossGradMaker); REGISTER_OPERATOR(margin_rank_loss_grad, ops::MarginRankLossGradOp); REGISTER_OP_CPU_KERNEL( margin_rank_loss, diff --git a/paddle/fluid/operators/match_matrix_tensor_op.cc b/paddle/fluid/operators/match_matrix_tensor_op.cc index d30f396f9c1e8cf1c480c159ec9943b9542ca546..2aeb68ed9013e87f55a5039d954cbcd9c1272668 100644 --- a/paddle/fluid/operators/match_matrix_tensor_op.cc +++ b/paddle/fluid/operators/match_matrix_tensor_op.cc @@ -316,9 +316,11 @@ class CPUMatchMatrixTensorOPGradKernel : public framework::OpKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(match_matrix_tensor, ops::MatchMatrixTensorOP, - ops::MatchMatrixTensorOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + match_matrix_tensor, ops::MatchMatrixTensorOP, + ops::MatchMatrixTensorOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker) REGISTER_OPERATOR(match_matrix_tensor_grad, ops::MatchMatrixTensorOpGrad); REGISTER_OP_CPU_KERNEL(match_matrix_tensor, diff --git a/paddle/fluid/operators/matmul_op.cc b/paddle/fluid/operators/matmul_op.cc index e8a9b38c9c4a717b3728a78f4e0e2e274ca24f79..587d6bdc0d8306daea0b8bea097f44f965aabc15 100644 --- a/paddle/fluid/operators/matmul_op.cc +++ b/paddle/fluid/operators/matmul_op.cc @@ -471,21 +471,22 @@ class MatMulOpGrad : public framework::OperatorWithKernel { } }; -class MatMulOpGradMaker : public framework::SingleGradOpDescMaker { +template +class MatMulOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *retv = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *retv = new T(); retv->SetType("matmul_grad"); - retv->SetInput("X", Input("X")); - retv->SetInput("Y", Input("Y")); - retv->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - retv->SetOutput(framework::GradVarName("X"), InputGrad("X")); - retv->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); - retv->SetAttrMap(Attrs()); - return std::unique_ptr(retv); + retv->SetInput("X", this->Input("X")); + retv->SetInput("Y", this->Input("Y")); + retv->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + retv->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + retv->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); + retv->SetAttrMap(this->Attrs()); + return std::unique_ptr(retv); } }; } // namespace operators @@ -493,7 +494,8 @@ class MatMulOpGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(matmul, ops::MatMulOp, ops::MatMulOpMaker, - ops::MatMulOpGradMaker); + ops::MatMulOpGradMaker, + ops::MatMulOpGradMaker); REGISTER_OPERATOR(matmul_grad, ops::MatMulOpGrad); REGISTER_OP_CPU_KERNEL( matmul, ops::MatMulKernel, diff --git a/paddle/fluid/operators/max_sequence_len_op.cc b/paddle/fluid/operators/max_sequence_len_op.cc index b1e69f375d3274aade3184af02f7f914dba5db71..3ac9c584727e9278f07c6f321722c379037b93f5 100644 --- a/paddle/fluid/operators/max_sequence_len_op.cc +++ b/paddle/fluid/operators/max_sequence_len_op.cc @@ -64,7 +64,9 @@ class MaxSeqenceLenInferShape : public framework::InferShapeBase { } // namespace operators } // namespace paddle -REGISTER_OPERATOR(max_sequence_len, paddle::operators::MaxSeqenceLenOp, - paddle::operators::MaxSeqenceLenOpProtoMaker, - paddle::operators::MaxSeqenceLenInferShape, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + max_sequence_len, paddle::operators::MaxSeqenceLenOp, + paddle::operators::MaxSeqenceLenOpProtoMaker, + paddle::operators::MaxSeqenceLenInferShape, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/maxout_op.cc b/paddle/fluid/operators/maxout_op.cc index c05c1a282c295c9d9bbfabdf841a8e4b21837fd4..e051db8b89d571686c32447cb7b32ee1fa8fe6a0 100644 --- a/paddle/fluid/operators/maxout_op.cc +++ b/paddle/fluid/operators/maxout_op.cc @@ -100,8 +100,10 @@ class MaxOutOpGrad : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(maxout, ops::MaxOutOp, ops::MaxOutOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + maxout, ops::MaxOutOp, ops::MaxOutOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(maxout_grad, ops::MaxOutOpGrad); REGISTER_OP_CPU_KERNEL( maxout, ops::MaxOutKernel); diff --git a/paddle/fluid/operators/mean_iou_op.cc b/paddle/fluid/operators/mean_iou_op.cc index 615b9ea48477383f49783884259fdff533ef04b8..4bf46edad61ab988801ccd59589881a939124ae5 100644 --- a/paddle/fluid/operators/mean_iou_op.cc +++ b/paddle/fluid/operators/mean_iou_op.cc @@ -103,8 +103,10 @@ is based on area of rectangle. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(mean_iou, ops::MeanIoUOp, ops::MeanIoUOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + mean_iou, ops::MeanIoUOp, ops::MeanIoUOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(mean_iou, ops::MeanIoUKernel, ops::MeanIoUKernel, ops::MeanIoUKernel); diff --git a/paddle/fluid/operators/mean_op.cc b/paddle/fluid/operators/mean_op.cc index e19ac59ee576e83e6328fd6388bc481fe662819e..108002d85c753555062574399d0ea63b3f838780 100644 --- a/paddle/fluid/operators/mean_op.cc +++ b/paddle/fluid/operators/mean_op.cc @@ -70,18 +70,19 @@ class MeanGradOp : public framework::OperatorWithKernel { } }; -class MeanGradMaker : public framework::SingleGradOpDescMaker { +template +class MeanGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* grad_op = new T(); grad_op->SetType("mean_grad"); - grad_op->SetInput("X", Input("X")); - grad_op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - grad_op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - return std::unique_ptr(grad_op); + grad_op->SetInput("X", this->Input("X")); + grad_op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + grad_op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + return std::unique_ptr(grad_op); } }; @@ -92,7 +93,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(MeanGradNoNeedBufferVarsInference, "X"); namespace ops = paddle::operators; REGISTER_OPERATOR(mean, ops::MeanOp, ops::MeanOpMaker, ops::MeanOpInferVarType, - ops::MeanGradMaker); + ops::MeanGradMaker, + ops::MeanGradMaker); REGISTER_OPERATOR(mean_grad, ops::MeanGradOp, ops::MeanGradNoNeedBufferVarsInference); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/merge_lod_tensor_op.cc b/paddle/fluid/operators/merge_lod_tensor_op.cc index 67154447d1bbea7865eced09e2132991667e3776..e832aca3c64e9c9d07fc95c6faa52a47ff6c003b 100644 --- a/paddle/fluid/operators/merge_lod_tensor_op.cc +++ b/paddle/fluid/operators/merge_lod_tensor_op.cc @@ -213,20 +213,21 @@ class MergeLoDTensorInferShape : public framework::InferShapeBase { } }; -class MergeLoDTensorGradMaker : public framework::SingleGradOpDescMaker { +template +class MergeLoDTensorGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("split_lod_tensor"); - grad_op->SetInput("X", OutputGrad("Out")); - grad_op->SetInput("Mask", Input("Mask")); - grad_op->SetOutput("OutTrue", InputGrad("InTrue")); - grad_op->SetOutput("OutFalse", InputGrad("InFalse")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("X", this->OutputGrad("Out")); + grad_op->SetInput("Mask", this->Input("Mask")); + grad_op->SetOutput("OutTrue", this->InputGrad("InTrue")); + grad_op->SetOutput("OutFalse", this->InputGrad("InFalse")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -235,9 +236,12 @@ class MergeLoDTensorGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(merge_lod_tensor, ops::MergeLoDTensorOp, - ops::MergeLoDTensorOpProtoMaker, - ops::MergeLoDTensorInferShape, ops::MergeLoDTensorGradMaker); -REGISTER_OPERATOR(merge_lod_tensor_infer, ops::MergeLoDTensorInferOp, ops::MergeLoDTensorOpProtoMaker, ops::MergeLoDTensorInferShape, - paddle::framework::EmptyGradOpMaker); + ops::MergeLoDTensorGradMaker, + ops::MergeLoDTensorGradMaker); +REGISTER_OPERATOR( + merge_lod_tensor_infer, ops::MergeLoDTensorInferOp, + ops::MergeLoDTensorOpProtoMaker, ops::MergeLoDTensorInferShape, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/metrics/accuracy_op.cc b/paddle/fluid/operators/metrics/accuracy_op.cc index 937b987b88cf51f010d6704a65831cc164aac314..1178b2cc03a6bd4f2f1fcfa2d991f4f6b0b110cb 100644 --- a/paddle/fluid/operators/metrics/accuracy_op.cc +++ b/paddle/fluid/operators/metrics/accuracy_op.cc @@ -106,8 +106,10 @@ with the input Out(Inference). } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(accuracy, ops::AccuracyOp, ops::AccuracyOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + accuracy, ops::AccuracyOp, ops::AccuracyOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); // FIXME(typhoonzero): types of T is for infernece data. // label data is always int. REGISTER_OP_CPU_KERNEL(accuracy, diff --git a/paddle/fluid/operators/modified_huber_loss_op.cc b/paddle/fluid/operators/modified_huber_loss_op.cc index 4029119ba57be1d393932c6e684fd6eaff96dde7..0c375eb5de09c9262077aadf6e96fc90a0519bd6 100644 --- a/paddle/fluid/operators/modified_huber_loss_op.cc +++ b/paddle/fluid/operators/modified_huber_loss_op.cc @@ -111,20 +111,20 @@ class ModifiedHuberLossGradOp : public framework::OperatorWithKernel { } }; -class ModifiedHuberLossGradOpDescMaker - : public framework::SingleGradOpDescMaker { +template +class ModifiedHuberLossGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("modified_huber_loss_grad"); - op->SetInput("Y", Input("Y")); - op->SetInput("IntermediateVal", Output("IntermediateVal")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("Y", this->Input("Y")); + op->SetInput("IntermediateVal", this->Output("IntermediateVal")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -133,9 +133,11 @@ class ModifiedHuberLossGradOpDescMaker } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(modified_huber_loss, ops::ModifiedHuberLossOp, - ops::ModifiedHuberLossOpMaker, - ops::ModifiedHuberLossGradOpDescMaker); +REGISTER_OPERATOR( + modified_huber_loss, ops::ModifiedHuberLossOp, + ops::ModifiedHuberLossOpMaker, + ops::ModifiedHuberLossGradOpMaker, + ops::ModifiedHuberLossGradOpMaker); REGISTER_OPERATOR(modified_huber_loss_grad, ops::ModifiedHuberLossGradOp); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/mul_op.cc b/paddle/fluid/operators/mul_op.cc index 119aa6888399d703f60e3a0c3c62b937ed26034e..9de7717b8fc9bd1fe0baaeb77eb0445d4cc038cf 100644 --- a/paddle/fluid/operators/mul_op.cc +++ b/paddle/fluid/operators/mul_op.cc @@ -225,20 +225,21 @@ class MulGradOp : public framework::OperatorWithKernel { } }; -class MulOpGradMaker : public framework::SingleGradOpDescMaker { +template +class MulOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr retv(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr retv(new T()); retv->SetType("mul_grad"); - retv->SetInput("X", Input("X")); - retv->SetInput("Y", Input("Y")); - retv->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - retv->SetOutput(framework::GradVarName("X"), InputGrad("X")); - retv->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); - retv->SetAttrMap(Attrs()); + retv->SetInput("X", this->Input("X")); + retv->SetInput("Y", this->Input("Y")); + retv->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + retv->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + retv->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); + retv->SetAttrMap(this->Attrs()); return retv; } }; @@ -265,32 +266,32 @@ class MulDoubleGradOp : public framework::OperatorWithKernel { } }; -class MulDoubleGradMaker : public framework::SingleGradOpDescMaker { +template +class MulDoubleGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr retv(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr retv(new T()); retv->SetType("mul_grad_grad"); - retv->SetInput("X", Input("X")); - retv->SetInput("Y", Input("Y")); - retv->SetInput("DOut", Input(framework::GradVarName("Out"))); - retv->SetInput("DDX", OutputGrad(framework::GradVarName("X"))); - retv->SetInput("DDY", OutputGrad(framework::GradVarName("Y"))); + retv->SetInput("X", this->Input("X")); + retv->SetInput("Y", this->Input("Y")); + retv->SetInput("DOut", this->Input(framework::GradVarName("Out"))); + retv->SetInput("DDX", this->OutputGrad(framework::GradVarName("X"))); + retv->SetInput("DDY", this->OutputGrad(framework::GradVarName("Y"))); - auto ddx = OutputGrad(framework::GradVarName("X")); - auto ddw = OutputGrad(framework::GradVarName("Y")); - std::vector empty_str = {}; + auto ddx = this->OutputGrad(framework::GradVarName("X")); + auto ddw = this->OutputGrad(framework::GradVarName("Y")); if (!ddx.empty() || !ddw.empty()) { - retv->SetOutput("DDOut", InputGrad(framework::GradVarName("Out"))); + retv->SetOutput("DDOut", this->InputGrad(framework::GradVarName("Out"))); } - retv->SetOutput("DX", ddw.empty() ? empty_str : InputGrad("X")); - retv->SetOutput("DY", ddx.empty() ? empty_str : InputGrad("Y")); + retv->SetOutput("DX", ddw.empty() ? this->Empty() : this->InputGrad("X")); + retv->SetOutput("DY", ddx.empty() ? this->Empty() : this->InputGrad("Y")); - retv->SetAttrMap(Attrs()); + retv->SetAttrMap(this->Attrs()); return retv; } }; @@ -300,9 +301,12 @@ class MulDoubleGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(mul, ops::MulOp, ops::MulOpMaker, ops::MulOpInferVarType, - ops::MulOpGradMaker); + ops::MulOpGradMaker, + ops::MulOpGradMaker); -REGISTER_OPERATOR(mul_grad, ops::MulGradOp, ops::MulDoubleGradMaker); +REGISTER_OPERATOR(mul_grad, ops::MulGradOp, + ops::MulDoubleGradMaker, + ops::MulDoubleGradMaker); REGISTER_OPERATOR(mul_grad_grad, ops::MulDoubleGradOp); diff --git a/paddle/fluid/operators/multiplex_op.cc b/paddle/fluid/operators/multiplex_op.cc index 843f0a68e1d6832f87acc0b2b838afe61c9a6704..961a80398a252b5b0dcce9e09ee240044780ef1f 100644 --- a/paddle/fluid/operators/multiplex_op.cc +++ b/paddle/fluid/operators/multiplex_op.cc @@ -132,18 +132,19 @@ class MultiplexGradOp : public framework::OperatorWithKernel { } }; -class MultiplexGradDescMaker : public framework::SingleGradOpDescMaker { +template +class MultiplexGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("multiplex_grad"); - op->SetInput("Ids", Input("Ids")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X", false)); - op->SetAttrMap(Attrs()); + op->SetInput("Ids", this->Input("Ids")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X", false)); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -154,7 +155,8 @@ class MultiplexGradDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(multiplex, ops::MultiplexOp, ops::MultiplexOpMaker, - ops::MultiplexGradDescMaker); + ops::MultiplexGradMaker, + ops::MultiplexGradMaker); REGISTER_OPERATOR(multiplex_grad, ops::MultiplexGradOp); REGISTER_OP_CPU_KERNEL( multiplex, diff --git a/paddle/fluid/operators/nccl/nccl_op.cc b/paddle/fluid/operators/nccl/nccl_op.cc index 6a0ae0dede695d80508bcc92a7a13ae9f73c3c57..8cf43be35cef64d5a9710901c52fa9dfe62eed72 100644 --- a/paddle/fluid/operators/nccl/nccl_op.cc +++ b/paddle/fluid/operators/nccl/nccl_op.cc @@ -230,10 +230,12 @@ Bcast the tensors. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(ncclInit, ops::NCCLInitOp, - paddle::framework::EmptyGradOpMaker, ops::NCCLInitOpMaker, - ops::NCCLInitOpVarTypeInference, - ops::NCCLInitOpShapeInference); +REGISTER_OPERATOR( + ncclInit, ops::NCCLInitOp, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::NCCLInitOpMaker, ops::NCCLInitOpVarTypeInference, + ops::NCCLInitOpShapeInference); REGISTER_OP_WITHOUT_GRADIENT(ncclAllReduce, ops::NCCLAllReduceOp, ops::NCCLAllReduceOpMaker); diff --git a/paddle/fluid/operators/nce_op.cc b/paddle/fluid/operators/nce_op.cc index 0f26e3953feeb55fd378d74d2c0dece7bf4d863a..86816a767804db7542ecc34b02cb653d0207f591 100644 --- a/paddle/fluid/operators/nce_op.cc +++ b/paddle/fluid/operators/nce_op.cc @@ -277,9 +277,11 @@ class NCEOpGradVarTypeInference : public framework::VarTypeInference { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(nce, ops::NCEOp, - paddle::framework::DefaultGradOpDescMaker, - ops::NCEOpMaker); +REGISTER_OPERATOR( + nce, ops::NCEOp, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker, + ops::NCEOpMaker); REGISTER_OPERATOR(nce_grad, ops::NCEOpGrad, ops::NCEOpGradVarTypeInference); REGISTER_OP_CPU_KERNEL(nce, ops::NCEKernel, ops::NCEKernel); diff --git a/paddle/fluid/operators/norm_op.cc b/paddle/fluid/operators/norm_op.cc index 81fbe3e514241ecdd2832141eba4250ced2017a9..ba0108304b988ea8f6143a06d60cee5d4f4eda1a 100644 --- a/paddle/fluid/operators/norm_op.cc +++ b/paddle/fluid/operators/norm_op.cc @@ -79,19 +79,20 @@ class NormOpGrad : public framework::OperatorWithKernel { } }; -class NormOpGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class NormOpGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("norm_grad"); - op->SetAttrMap(Attrs()); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput("Norm", Output("Norm")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); + op->SetAttrMap(this->Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput("Norm", this->Output("Norm")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); return op; } }; @@ -103,7 +104,8 @@ namespace ops = paddle::operators; using CPU = paddle::platform::CPUDeviceContext; REGISTER_OPERATOR(norm, ops::NormOp, ops::NormOpMaker, - ops::NormOpGradOpDescMaker); + ops::NormOpGradOpMaker, + ops::NormOpGradOpMaker); REGISTER_OPERATOR(norm_grad, ops::NormOpGrad); REGISTER_OP_CPU_KERNEL(norm, ops::NormKernel, ops::NormKernel); diff --git a/paddle/fluid/operators/one_hot_op.cc b/paddle/fluid/operators/one_hot_op.cc index e4d50db30a3f0caae6b5733f1015534d2c3cd7e8..40f2dc697b25bb28b6ab07ff2c750e4aa2c0c4a8 100644 --- a/paddle/fluid/operators/one_hot_op.cc +++ b/paddle/fluid/operators/one_hot_op.cc @@ -119,8 +119,10 @@ Out is a LoDTensor: } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(one_hot, ops::OneHotOp, ops::OneHotOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + one_hot, ops::OneHotOp, ops::OneHotOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( one_hot, ops::OneHotKernel, ops::OneHotKernel); diff --git a/paddle/fluid/operators/one_hot_v2_op.cc b/paddle/fluid/operators/one_hot_v2_op.cc index 62f85496f9b9f6362112de267bba152ab03589a6..94a42bef5a35864b8a216d468256baa3955d88f7 100644 --- a/paddle/fluid/operators/one_hot_v2_op.cc +++ b/paddle/fluid/operators/one_hot_v2_op.cc @@ -116,8 +116,10 @@ Out is a LoDTensor: } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(one_hot_v2, ops::OneHotV2Op, ops::OneHotV2OpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + one_hot_v2, ops::OneHotV2Op, ops::OneHotV2OpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( one_hot_v2, ops::OneHotV2Kernel, ops::OneHotV2Kernel); diff --git a/paddle/fluid/operators/optimizers/lars_momentum_op.cc b/paddle/fluid/operators/optimizers/lars_momentum_op.cc index 126b665dd4d9301ae67346afa45a250accfec656..5f0500d2faa77f7c2e901c0d30ab2c42036d2a86 100644 --- a/paddle/fluid/operators/optimizers/lars_momentum_op.cc +++ b/paddle/fluid/operators/optimizers/lars_momentum_op.cc @@ -78,8 +78,10 @@ class LarsMomentumOpVarTypeInference : public framework::VarTypeInference { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(lars_momentum, ops::MomentumOp, ops::LarsMomentumOpMaker, - paddle::framework::EmptyGradOpMaker, - ops::LarsMomentumOpVarTypeInference); +REGISTER_OPERATOR( + lars_momentum, ops::MomentumOp, ops::LarsMomentumOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::LarsMomentumOpVarTypeInference); REGISTER_OP_CPU_KERNEL(lars_momentum, ops::LarsMomentumOpKernel, ops::LarsMomentumOpKernel); diff --git a/paddle/fluid/operators/optimizers/momentum_op.cc b/paddle/fluid/operators/optimizers/momentum_op.cc index 111f104d273f98685f5680843d3be3c345d0c9eb..a0dc387fb677eef2209596823b448fddb3af7cf4 100644 --- a/paddle/fluid/operators/optimizers/momentum_op.cc +++ b/paddle/fluid/operators/optimizers/momentum_op.cc @@ -85,9 +85,11 @@ $$ } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(momentum, ops::MomentumOp, ops::MomentumOpMaker, - paddle::framework::EmptyGradOpMaker, - ops::MomentumOpInferVarType); +REGISTER_OPERATOR( + momentum, ops::MomentumOp, ops::MomentumOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::MomentumOpInferVarType); REGISTER_OP_CPU_KERNEL( momentum, ops::MomentumOpKernel, ops::MomentumOpKernel); diff --git a/paddle/fluid/operators/optimizers/sgd_op.cc b/paddle/fluid/operators/optimizers/sgd_op.cc index dcc6ce41b279803d8a84b7cfb6e94df6f3cd06f8..aad5677b970452c29354ff8da9b137c448cae8f2 100644 --- a/paddle/fluid/operators/optimizers/sgd_op.cc +++ b/paddle/fluid/operators/optimizers/sgd_op.cc @@ -108,8 +108,11 @@ $$param\_out = param - learning\_rate * grad$$ } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(sgd, ops::SGDOp, ops::SGDOpMaker, - paddle::framework::EmptyGradOpMaker, ops::SGDOpInferVarType); +REGISTER_OPERATOR( + sgd, ops::SGDOp, ops::SGDOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::SGDOpInferVarType); REGISTER_OP_CPU_KERNEL( sgd, ops::SGDOpKernel, ops::SGDOpKernel); diff --git a/paddle/fluid/operators/optimizers/sgd_op.cu b/paddle/fluid/operators/optimizers/sgd_op.cu index 40b9d03f85301e7257287613eb020a49321655e5..ebe7814aa7e2ce25ff955e5d3b8a6fe0c11f897f 100644 --- a/paddle/fluid/operators/optimizers/sgd_op.cu +++ b/paddle/fluid/operators/optimizers/sgd_op.cu @@ -73,8 +73,12 @@ class SGDOpKernel if (grad_var->IsType()) { param_out->mutable_data(ctx.GetPlace()); auto* grad = ctx.Input("Grad"); + // LOG(ERROR) << "grad"; + // LOG(ERROR) << ctx.op().Input("Grad"); auto* grad_data = grad->data(); + // LOG(ERROR) << "param"; auto* param_data = param->data(); + // LOG(ERROR) << "fin"; auto* param_out_data = param_out->data(); int block = 512; diff --git a/paddle/fluid/operators/pad2d_op.cc b/paddle/fluid/operators/pad2d_op.cc index 461db5fdc9421d2f7728e496a88f57d188bbf5c0..71919667ba1bbaf3456b074c261dd714078681bf 100644 --- a/paddle/fluid/operators/pad2d_op.cc +++ b/paddle/fluid/operators/pad2d_op.cc @@ -627,22 +627,23 @@ class Pad2dOpGrad : public framework::OperatorWithKernel { } }; -class Pad2dOpGradMaker : public framework::SingleGradOpDescMaker { +template +class Pad2dOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* bind = new framework::OpDesc(); - bind->SetInput("X", Input("X")); - if (ForwardOp().Inputs().count("Paddings") > 0) { - bind->SetInput("Paddings", Input("Paddings")); + std::unique_ptr Apply() const override { + auto* bind = new T(); + bind->SetInput("X", this->Input("X")); + if (this->HasInput("Paddings")) { + bind->SetInput("Paddings", this->Input("Paddings")); } - bind->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - bind->SetOutput(framework::GradVarName("X"), InputGrad("X")); - bind->SetAttrMap(Attrs()); + bind->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + bind->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + bind->SetAttrMap(this->Attrs()); bind->SetType("pad2d_grad"); - return std::unique_ptr(bind); + return std::unique_ptr(bind); } }; @@ -656,7 +657,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(Pad2dOpGradNoNeedBufferVarsInference, namespace ops = paddle::operators; REGISTER_OPERATOR(pad2d, ops::Pad2dOp, ops::Pad2dOpMaker, - ops::Pad2dOpGradMaker); + ops::Pad2dOpGradMaker, + ops::Pad2dOpGradMaker); REGISTER_OPERATOR(pad2d_grad, ops::Pad2dOpGrad, ops::Pad2dOpGradNoNeedBufferVarsInference); REGISTER_OP_CPU_KERNEL(pad2d, ops::Pad2dCPUKernel); diff --git a/paddle/fluid/operators/pad_constant_like_op.cc b/paddle/fluid/operators/pad_constant_like_op.cc index 1c4bf7035ef978abf9c5dcdab8872181c6af477f..d408275d8e5ca9ee97b3ca4dc99f7154ffa6cc5a 100644 --- a/paddle/fluid/operators/pad_constant_like_op.cc +++ b/paddle/fluid/operators/pad_constant_like_op.cc @@ -193,19 +193,20 @@ class PadConstantLikeOpGrad : public framework::OperatorWithKernel { } }; -class PadConstantLikeOpGradMaker : public framework::SingleGradOpDescMaker { +template +class PadConstantLikeOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *bind = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *bind = new T(); bind->SetType("pad_constant_like_grad"); - bind->SetInput("Y", Input("Y")); - bind->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - bind->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); - bind->SetAttrMap(Attrs()); - return std::unique_ptr(bind); + bind->SetInput("Y", this->Input("Y")); + bind->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + bind->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); + bind->SetAttrMap(this->Attrs()); + return std::unique_ptr(bind); } }; @@ -215,7 +216,9 @@ class PadConstantLikeOpGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(pad_constant_like, ops::PadConstantLikeOp, - ops::PadConstantLikeOpMaker, ops::PadConstantLikeOpGradMaker); + ops::PadConstantLikeOpMaker, + ops::PadConstantLikeOpGradMaker, + ops::PadConstantLikeOpGradMaker); REGISTER_OPERATOR(pad_constant_like_grad, ops::PadConstantLikeOpGrad); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/pad_op.cc b/paddle/fluid/operators/pad_op.cc index 36dc8b0dbb3d3b6537b6395f4c831ac25b03a4c6..b98f201e8a1699577d8948f3754ddc2c00c05841 100644 --- a/paddle/fluid/operators/pad_op.cc +++ b/paddle/fluid/operators/pad_op.cc @@ -121,18 +121,19 @@ class PadOpGrad : public framework::OperatorWithKernel { } }; -class PadOpGradMaker : public framework::SingleGradOpDescMaker { +template +class PadOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* bind = new framework::OpDesc(); - bind->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - bind->SetOutput(framework::GradVarName("X"), InputGrad("X")); - bind->SetAttrMap(Attrs()); + std::unique_ptr Apply() const override { + auto* bind = new T(); + bind->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + bind->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + bind->SetAttrMap(this->Attrs()); bind->SetType("pad_grad"); - return std::unique_ptr(bind); + return std::unique_ptr(bind); } }; @@ -141,7 +142,9 @@ class PadOpGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; -REGISTER_OPERATOR(pad, ops::PadOp, ops::PadOpMaker, ops::PadOpGradMaker); +REGISTER_OPERATOR(pad, ops::PadOp, ops::PadOpMaker, + ops::PadOpGradMaker, + ops::PadOpGradMaker); REGISTER_OPERATOR(pad_grad, ops::PadOpGrad); REGISTER_OP_CPU_KERNEL( pad, ops::PadKernel); diff --git a/paddle/fluid/operators/pixel_shuffle_op.cc b/paddle/fluid/operators/pixel_shuffle_op.cc index 59ba660af79bff02cd350afb3eb7675bfe8ac498..d34596c2dedff5c00c2c3cc26b1a082f80f2c2ed 100644 --- a/paddle/fluid/operators/pixel_shuffle_op.cc +++ b/paddle/fluid/operators/pixel_shuffle_op.cc @@ -77,17 +77,18 @@ class PixelShuffleOpMaker : public framework::OpProtoAndCheckerMaker { } }; -class PixelShuffleGradMaker : public framework::SingleGradOpDescMaker { +template +class PixelShuffleGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("pixel_shuffle_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetAttrMap(Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - return std::unique_ptr(op); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetAttrMap(this->Attrs()); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + return std::unique_ptr(op); } }; @@ -120,7 +121,8 @@ class PixelShuffleGradOp : public framework::OperatorWithKernel { namespace ops = paddle::operators; REGISTER_OPERATOR(pixel_shuffle, ops::PixelShuffleOp, ops::PixelShuffleOpMaker, - ops::PixelShuffleGradMaker); + ops::PixelShuffleGradMaker, + ops::PixelShuffleGradMaker); REGISTER_OPERATOR(pixel_shuffle_grad, ops::PixelShuffleGradOp); diff --git a/paddle/fluid/operators/pool_op.cc b/paddle/fluid/operators/pool_op.cc index 6ece163f69770ecfea4d9aa280d19913a2bb2842..817ad336cf60158e8c8798805e1176557cd65c8e 100644 --- a/paddle/fluid/operators/pool_op.cc +++ b/paddle/fluid/operators/pool_op.cc @@ -571,9 +571,10 @@ Example: namespace ops = paddle::operators; -REGISTER_OPERATOR(pool2d, ops::PoolOp, ops::Pool2dOpMaker, - ops::PoolOpInferVarType, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + pool2d, ops::PoolOp, ops::Pool2dOpMaker, ops::PoolOpInferVarType, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(pool2d_grad, ops::PoolOpGrad); REGISTER_OP_CPU_KERNEL( @@ -583,9 +584,10 @@ REGISTER_OP_CPU_KERNEL( pool2d_grad, ops::PoolGradKernel, ops::PoolGradKernel); -REGISTER_OPERATOR(pool3d, ops::PoolOp, ops::Pool3dOpMaker, - ops::PoolOpInferVarType, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + pool3d, ops::PoolOp, ops::Pool3dOpMaker, ops::PoolOpInferVarType, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(pool3d_grad, ops::PoolOpGrad); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/pool_with_index_op.cc b/paddle/fluid/operators/pool_with_index_op.cc index d8c2ccaa96079393aacb53f841dfea0562004fb4..f8148f946fcddfea23ab2f58b40216f5ff0f715f 100644 --- a/paddle/fluid/operators/pool_with_index_op.cc +++ b/paddle/fluid/operators/pool_with_index_op.cc @@ -288,9 +288,11 @@ Example: namespace ops = paddle::operators; -REGISTER_OPERATOR(max_pool2d_with_index, ops::MaxPoolWithIndexOp, - ops::MaxPool2dWithIndexOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + max_pool2d_with_index, ops::MaxPoolWithIndexOp, + ops::MaxPool2dWithIndexOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(max_pool2d_with_index_grad, ops::MaxPoolWithIndexOpGrad); REGISTER_OP_CPU_KERNEL( @@ -305,9 +307,11 @@ REGISTER_OP_CPU_KERNEL( ops::MaxPoolWithIndexGradKernel); -REGISTER_OPERATOR(max_pool3d_with_index, ops::MaxPoolWithIndexOp, - ops::MaxPool3dWithIndexOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + max_pool3d_with_index, ops::MaxPoolWithIndexOp, + ops::MaxPool3dWithIndexOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(max_pool3d_with_index_grad, ops::MaxPoolWithIndexOpGrad); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/prelu_op.cc b/paddle/fluid/operators/prelu_op.cc index 364f3689f9fa810d37a8f4746e079e29d47645a4..5408e7bf0d3abe28ab7368c9b43a471685d792f2 100644 --- a/paddle/fluid/operators/prelu_op.cc +++ b/paddle/fluid/operators/prelu_op.cc @@ -124,8 +124,10 @@ class PReluGradOp : public framework::OperatorWithKernel { namespace ops = paddle::operators; -REGISTER_OPERATOR(prelu, ops::PReluOp, ops::PReluOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + prelu, ops::PReluOp, ops::PReluOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(prelu_grad, ops::PReluGradOp); REGISTER_OP_CPU_KERNEL( prelu, ops::PReluKernel); diff --git a/paddle/fluid/operators/print_op.cc b/paddle/fluid/operators/print_op.cc index f686e5293b0f504863e228d37db56c6df4954c24..37e062982e1f6e919eb78c79fd21c64c1184b20d 100644 --- a/paddle/fluid/operators/print_op.cc +++ b/paddle/fluid/operators/print_op.cc @@ -261,18 +261,19 @@ class PrintOpVarTypeInference : public framework::VarTypeInference { } }; -class PrintOpGradientMaker : public framework::SingleGradOpDescMaker { +template +class PrintOpGradientMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto *op_desc_ptr = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *op_desc_ptr = new T(); op_desc_ptr->SetType("print"); - op_desc_ptr->SetInput("In", OutputGrad("Out")); - op_desc_ptr->SetOutput("Out", InputGrad("In")); - op_desc_ptr->SetAttrMap(Attrs()); + op_desc_ptr->SetInput("In", this->OutputGrad("Out")); + op_desc_ptr->SetOutput("Out", this->InputGrad("In")); + op_desc_ptr->SetAttrMap(this->Attrs()); op_desc_ptr->SetAttr("is_forward", false); - return std::unique_ptr(op_desc_ptr); + return std::unique_ptr(op_desc_ptr); } }; @@ -282,5 +283,6 @@ class PrintOpGradientMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(print, ops::PrintOp, ops::PrintOpProtoAndCheckMaker, - ops::PrintOpGradientMaker, ops::PrintOpInferShape, - ops::PrintOpVarTypeInference); + ops::PrintOpGradientMaker, + ops::PrintOpGradientMaker, + ops::PrintOpInferShape, ops::PrintOpVarTypeInference); diff --git a/paddle/fluid/operators/prroi_pool_op.cc b/paddle/fluid/operators/prroi_pool_op.cc index c11d09350a477e59fdde5d1caa01b87a7d870daa..85e15d0ed1be83992254b32e4aa178da7fa712a9 100644 --- a/paddle/fluid/operators/prroi_pool_op.cc +++ b/paddle/fluid/operators/prroi_pool_op.cc @@ -142,21 +142,22 @@ class PRROIPoolGradOp : public framework::OperatorWithKernel { } }; -class PRROIPoolGradDescMaker : public framework::SingleGradOpDescMaker { +template +class PRROIPoolGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("prroi_pool_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Out", Output("Out")); - op->SetInput("ROIs", Input("ROIs")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("ROIs"), InputGrad("ROIs")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Out", this->Output("Out")); + op->SetInput("ROIs", this->Input("ROIs")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("ROIs"), this->InputGrad("ROIs")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -165,7 +166,8 @@ class PRROIPoolGradDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(prroi_pool, ops::PRROIPoolOp, ops::PRROIPoolOpMaker, - ops::PRROIPoolGradDescMaker); + ops::PRROIPoolGradMaker, + ops::PRROIPoolGradMaker); REGISTER_OPERATOR(prroi_pool_grad, ops::PRROIPoolGradOp); REGISTER_OP_CPU_KERNEL( prroi_pool, diff --git a/paddle/fluid/operators/psroi_pool_op.cc b/paddle/fluid/operators/psroi_pool_op.cc index a9128fbd28db82440225b56833a5528ef2cecce6..4bbd0e2b793ba6a9b76784f7920a2ded70ebf0a1 100644 --- a/paddle/fluid/operators/psroi_pool_op.cc +++ b/paddle/fluid/operators/psroi_pool_op.cc @@ -158,19 +158,20 @@ class PSROIPoolGradOp : public framework::OperatorWithKernel { } }; -class PSROIPoolGradDescMaker : public framework::SingleGradOpDescMaker { +template +class PSROIPoolGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("psroi_pool_grad"); - op->SetInput("X", Input("X")); - op->SetInput("ROIs", Input("ROIs")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("ROIs", this->Input("ROIs")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -180,7 +181,8 @@ class PSROIPoolGradDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(psroi_pool, ops::PSROIPoolOp, ops::PSROIPoolOpMaker, - ops::PSROIPoolGradDescMaker); + ops::PSROIPoolGradMaker, + ops::PSROIPoolGradMaker); REGISTER_OPERATOR(psroi_pool_grad, ops::PSROIPoolGradOp); REGISTER_OP_CPU_KERNEL( psroi_pool, diff --git a/paddle/fluid/operators/pull_box_sparse_op.cc b/paddle/fluid/operators/pull_box_sparse_op.cc index 3af3fb4967590068fa2a936cbb2e01db583e565a..972a31a62cb812cc7f3e7c8686a4ad3db3c3088f 100644 --- a/paddle/fluid/operators/pull_box_sparse_op.cc +++ b/paddle/fluid/operators/pull_box_sparse_op.cc @@ -79,18 +79,19 @@ or not. And the output only shares the LoD information with input Ids. } }; -class PushBoxSparseOpDescMaker : public framework::SingleGradOpDescMaker { +template +class PushBoxSparseOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("push_box_sparse"); - op->SetInput("Ids", Input("Ids")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetAttrMap(Attrs()); + op->SetInput("Ids", this->Input("Ids")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -114,7 +115,9 @@ class PushBoxSparseOp : public framework::OperatorWithKernel { namespace ops = paddle::operators; REGISTER_OPERATOR(pull_box_sparse, ops::PullBoxSparseOp, - ops::PullBoxSparseOpMaker, ops::PushBoxSparseOpDescMaker); + ops::PullBoxSparseOpMaker, + ops::PushBoxSparseOpMaker, + ops::PushBoxSparseOpMaker); REGISTER_OPERATOR(push_box_sparse, ops::PushBoxSparseOp); REGISTER_OP_CPU_KERNEL(pull_box_sparse, ops::PullBoxSparseCPUKernel) REGISTER_OP_CPU_KERNEL(push_box_sparse, ops::PushBoxSparseCPUKernel) diff --git a/paddle/fluid/operators/pyramid_hash_op.cc b/paddle/fluid/operators/pyramid_hash_op.cc index e0b63d2ead770e34f24d8aaa61b5ed12dcd5b3e8..363f4dcf4ade31f1b69de20d23e0aa65b55585fd 100644 --- a/paddle/fluid/operators/pyramid_hash_op.cc +++ b/paddle/fluid/operators/pyramid_hash_op.cc @@ -336,22 +336,24 @@ class PyramidHashOpGrad : public framework::OperatorWithKernel { } }; -class PyramidHashGradOpMaker : public framework::SingleGradOpDescMaker { +template +class PyramidHashGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* op_desc_ptr = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op_desc_ptr = new T(); op_desc_ptr->SetType("pyramid_hash_grad"); - op_desc_ptr->SetInput("X", Input("X")); - op_desc_ptr->SetInput("W", Input("W")); - op_desc_ptr->SetInput("DropPos", Output("DropPos")); - - op_desc_ptr->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op_desc_ptr->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op_desc_ptr->SetAttrMap(Attrs()); - return std::unique_ptr(op_desc_ptr); + op_desc_ptr->SetInput("X", this->Input("X")); + op_desc_ptr->SetInput("W", this->Input("W")); + op_desc_ptr->SetInput("DropPos", this->Output("DropPos")); + + op_desc_ptr->SetInput(framework::GradVarName("Out"), + this->OutputGrad("Out")); + op_desc_ptr->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op_desc_ptr->SetAttrMap(this->Attrs()); + return std::unique_ptr(op_desc_ptr); } }; @@ -435,7 +437,8 @@ namespace ops = paddle::operators; namespace plt = paddle::platform; namespace frm = paddle::framework; REGISTER_OPERATOR(pyramid_hash, ops::PyramidHashOP, ops::PyramidHashOpMaker, - ops::PyramidHashGradOpMaker); + ops::PyramidHashGradOpMaker, + ops::PyramidHashGradOpMaker); REGISTER_OPERATOR(pyramid_hash_grad, ops::PyramidHashOpGrad); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/random_crop_op.cc b/paddle/fluid/operators/random_crop_op.cc index 15911a51a2c8e56c4279931b4fcebe35ce7b268c..acb6ca84ca3d3cfd763f0b4b6f205aada7ce550f 100644 --- a/paddle/fluid/operators/random_crop_op.cc +++ b/paddle/fluid/operators/random_crop_op.cc @@ -75,8 +75,11 @@ class RandomCropOpInferShape : public framework::InferShapeBase { namespace ops = paddle::operators; namespace f = paddle::framework; -REGISTER_OPERATOR(random_crop, ops::RandomCropOp, ops::RandomCropOpMaker, - ops::RandomCropOpInferShape, f::EmptyGradOpMaker); +REGISTER_OPERATOR( + random_crop, ops::RandomCropOp, ops::RandomCropOpMaker, + ops::RandomCropOpInferShape, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); template using Kernel = ops::RandomCropKernel; diff --git a/paddle/fluid/operators/rank_loss_op.cc b/paddle/fluid/operators/rank_loss_op.cc index a0fe1cae4e69563b41319e0d5d28e662d6722c55..3894b5a46a690a68db2dfcb79c0743deb320e776 100644 --- a/paddle/fluid/operators/rank_loss_op.cc +++ b/paddle/fluid/operators/rank_loss_op.cc @@ -156,21 +156,22 @@ class RankLossGradOp : public framework::OperatorWithKernel { } }; -class RankLossGradDescMaker : public framework::SingleGradOpDescMaker { +template +class RankLossGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("rank_loss_grad"); - op->SetInput("Label", Input("Label")); - op->SetInput("Left", Input("Left")); - op->SetInput("Right", Input("Right")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("Left"), InputGrad("Left")); - op->SetOutput(framework::GradVarName("Right"), InputGrad("Right")); - op->SetAttrMap(Attrs()); + op->SetInput("Label", this->Input("Label")); + op->SetInput("Left", this->Input("Left")); + op->SetInput("Right", this->Input("Right")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("Left"), this->InputGrad("Left")); + op->SetOutput(framework::GradVarName("Right"), this->InputGrad("Right")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -180,7 +181,8 @@ class RankLossGradDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(rank_loss, ops::RankLossOp, ops::RankLossOpMaker, - ops::RankLossGradDescMaker); + ops::RankLossGradMaker, + ops::RankLossGradMaker); REGISTER_OPERATOR(rank_loss_grad, ops::RankLossGradOp); REGISTER_OP_CPU_KERNEL( rank_loss, ops::RankLossKernel); diff --git a/paddle/fluid/operators/reader/create_custom_reader_op.cc b/paddle/fluid/operators/reader/create_custom_reader_op.cc index 975f7b991f80ee292aa7eb02109ab5e518331726..a7d815367f33c4cdb28c94c03fe013916a3cf45b 100644 --- a/paddle/fluid/operators/reader/create_custom_reader_op.cc +++ b/paddle/fluid/operators/reader/create_custom_reader_op.cc @@ -183,7 +183,9 @@ void CustomReader::ReadNextImpl(std::vector* out) { } // namespace paddle namespace ops = paddle::operators::reader; -REGISTER_OPERATOR(create_custom_reader, ops::CreateCustomReaderOp, - ops::CreateCustomReaderOpMaker, ops::CustomReaderInferShape, - ops::CustomReaderInferVarType, - paddle::framework::EmptyGradOpMaker) +REGISTER_OPERATOR( + create_custom_reader, ops::CreateCustomReaderOp, + ops::CreateCustomReaderOpMaker, ops::CustomReaderInferShape, + ops::CustomReaderInferVarType, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker) diff --git a/paddle/fluid/operators/reader/read_op.cc b/paddle/fluid/operators/reader/read_op.cc index bd4e3e293da966fb97a89600f58a1658d2b3dfd9..3da7c88f1fe001a8a2950edbedcf3582150f08ff 100644 --- a/paddle/fluid/operators/reader/read_op.cc +++ b/paddle/fluid/operators/reader/read_op.cc @@ -168,5 +168,8 @@ class ReadOpMaker : public framework::OpProtoAndCheckerMaker { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(read, ops::ReadOp, ops::ReadInferShape, ops::ReadOpMaker, - paddle::framework::EmptyGradOpMaker, ops::ReadInferVarType); +REGISTER_OPERATOR( + read, ops::ReadOp, ops::ReadInferShape, ops::ReadOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + ops::ReadInferVarType); diff --git a/paddle/fluid/operators/reader/reader_op_registry.h b/paddle/fluid/operators/reader/reader_op_registry.h index de0c34ad32e226cacc998767bf824e4a7c8a28ef..35a0dacaec2376db67484bf934dc523cf105f363 100644 --- a/paddle/fluid/operators/reader/reader_op_registry.h +++ b/paddle/fluid/operators/reader/reader_op_registry.h @@ -85,17 +85,20 @@ class DecoratedReaderMakerBase : public framework::OpProtoAndCheckerMaker { } // namespace operators } // namespace paddle -#define REGISTER_FILE_READER_OPERATOR(op_name, ...) \ - REGISTER_OPERATOR(op_name, __VA_ARGS__, \ - paddle::operators::reader::FileReaderInferShape, \ - paddle::framework::EmptyGradOpMaker, \ - paddle::operators::reader::FileReaderInferVarType) - -#define REGISTER_DECORATED_READER_OPERATOR(op_name, ...) \ - REGISTER_OPERATOR(op_name, __VA_ARGS__, \ - paddle::operators::reader::DecoratedReaderInferShape, \ - paddle::framework::EmptyGradOpMaker, \ - paddle::operators::reader::DecoratedReaderInferVarType) +#define REGISTER_FILE_READER_OPERATOR(op_name, ...) \ + REGISTER_OPERATOR( \ + op_name, __VA_ARGS__, paddle::operators::reader::FileReaderInferShape, \ + paddle::framework::EmptyGradOpMaker, \ + paddle::framework::EmptyGradOpMaker, \ + paddle::operators::reader::FileReaderInferVarType) + +#define REGISTER_DECORATED_READER_OPERATOR(op_name, ...) \ + REGISTER_OPERATOR( \ + op_name, __VA_ARGS__, \ + paddle::operators::reader::DecoratedReaderInferShape, \ + paddle::framework::EmptyGradOpMaker, \ + paddle::framework::EmptyGradOpMaker, \ + paddle::operators::reader::DecoratedReaderInferVarType) #define REGISTER_FILE_READER(_filetype, _reader) \ STATIC_ASSERT_GLOBAL_NAMESPACE( \ diff --git a/paddle/fluid/operators/recurrent_op.cc b/paddle/fluid/operators/recurrent_op.cc index c6751463e731fcde08c0e470131b073f52337b5b..88e1b479f1e4480dfbec227bc396c4ddd923e094 100644 --- a/paddle/fluid/operators/recurrent_op.cc +++ b/paddle/fluid/operators/recurrent_op.cc @@ -574,13 +574,14 @@ data, i.e. in each mini-batch, the sequence length of all inputs are the same. } }; -class RecurrentGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class RecurrentGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - virtual std::unique_ptr Apply() const { - auto *grad = new framework::OpDesc(); + virtual std::unique_ptr Apply() const { + auto *grad = new T(); grad->SetType("recurrent_grad"); for (auto &input_param : this->InputNames()) { grad->SetInput(input_param, this->Input(input_param)); @@ -600,9 +601,9 @@ class RecurrentGradOpDescMaker : public framework::SingleGradOpDescMaker { } } grad->SetAttrMap(this->Attrs()); - grad->SetBlockAttr(RecurrentBase::kStepBlock, grad_block_[0]); + grad->SetBlockAttr(RecurrentBase::kStepBlock, this->grad_block_[0]); - return std::unique_ptr(grad); + return std::unique_ptr(grad); } }; @@ -665,8 +666,9 @@ class RecurrentGradOpShapeInference : public framework::InferShapeBase { } // namespace operators } // namespace paddle -REGISTER_OPERATOR(recurrent, paddle::operators::RecurrentOp, - paddle::operators::RecurrentOpProtoMaker, - paddle::operators::RecurrentGradOpDescMaker); +REGISTER_OPERATOR( + recurrent, paddle::operators::RecurrentOp, + paddle::operators::RecurrentOpProtoMaker, + paddle::operators::RecurrentGradOpMaker); REGISTER_OPERATOR(recurrent_grad, paddle::operators::RecurrentGradOp, paddle::operators::RecurrentGradOpShapeInference); diff --git a/paddle/fluid/operators/reduce_ops/reduce_mean_op.cc b/paddle/fluid/operators/reduce_ops/reduce_mean_op.cc index e549d2bddfef07ab438f72ab7273418ef0f97728..b41a739440771cd4e694a2a3ccbd55728cb91ffc 100644 --- a/paddle/fluid/operators/reduce_ops/reduce_mean_op.cc +++ b/paddle/fluid/operators/reduce_ops/reduce_mean_op.cc @@ -24,23 +24,24 @@ namespace operators { // calcualtion, but will incur a reduce_mean_grad op after // reduce_mean_grad_grad, delete Input(Out) here. // This change has no effect on reduce_mean_grad calculations. -class ReduceMeanOpGradDescMaker : public framework::SingleGradOpDescMaker { +template +class ReduceMeanOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("reduce_mean_grad"); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetAttrMap(Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetAttrMap(this->Attrs()); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); return op; } }; -class ReduceMeanDoubleGradMaker : public framework::GradOpDescMakerBase { +class ReduceMeanDoubleGradDescMaker : public framework::GradOpDescMakerBase { public: using framework::GradOpDescMakerBase::GradOpDescMakerBase; @@ -60,7 +61,26 @@ class ReduceMeanDoubleGradMaker : public framework::GradOpDescMakerBase { return ops; } }; +class ReduceMeanDoubleGradOpBaseMaker : public imperative::GradOpBaseMakerBase { + public: + using imperative::GradOpBaseMakerBase::GradOpBaseMakerBase; + std::vector> operator()() const override { + std::vector> ops; + auto x_gg = OutputGrad(framework::GradVarName("X")); // input ddx + auto out_grads = InputGrad(framework::GradVarName("Out")); + if (!out_grads.empty()) { + auto* out_grad_op = new imperative::OpBase(); + out_grad_op->SetType("reduce_mean"); + out_grad_op->SetInput("X", x_gg); + out_grad_op->SetAttrMap(Attrs()); + out_grad_op->SetOutput("Out", out_grads); + ops.emplace_back(out_grad_op); + } + + return ops; + } +}; DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(ReduceMeanGradNoNeedBufferVarInference, "X"); } // namespace operators @@ -73,9 +93,11 @@ class __reduce_meanMaker__ : public ops::ReduceOpMaker { }; REGISTER_OPERATOR(reduce_mean, ops::ReduceOp, __reduce_meanMaker__, - ops::ReduceMeanOpGradDescMaker); + ops::ReduceMeanOpGradMaker, + ops::ReduceMeanOpGradMaker); REGISTER_OPERATOR(reduce_mean_grad, ops::ReduceGradOp, - ops::ReduceMeanDoubleGradMaker, + ops::ReduceMeanDoubleGradDescMaker, + ops::ReduceMeanDoubleGradOpBaseMaker, ops::ReduceMeanGradNoNeedBufferVarInference); REGISTER_OP_CPU_KERNEL(reduce_mean, ops::ReduceKernel, \ + paddle::framework::DefaultGradOpMaker); \ + REGISTER_OPERATOR(op_name##_grad, ops::ReduceGradOp) + +#define REGISTER_REDUCE_OP_WITHOUT_GRAD(op_name, ...) \ class __##op_name##Maker__ : public ops::ReduceOpMaker { \ protected: \ virtual std::string GetName() const { return #op_name; } \ virtual std::string GetOpType() const { return "Reduce " #op_name; } \ }; \ - REGISTER_OPERATOR(op_name, ops::ReduceOp, __##op_name##Maker__, \ - paddle::framework::DefaultGradOpDescMaker); \ - REGISTER_OPERATOR(op_name##_grad, ops::ReduceGradOp) - -#define REGISTER_REDUCE_OP_WITHOUT_GRAD(op_name, ...) \ - class __##op_name##Maker__ : public ops::ReduceOpMaker { \ - protected: \ - virtual std::string GetName() const { return #op_name; } \ - virtual std::string GetOpType() const { return "Reduce " #op_name; } \ - }; \ - REGISTER_OPERATOR(op_name, ops::ReduceOp##__VA_ARGS__, __##op_name##Maker__, \ - paddle::framework::EmptyGradOpMaker); + REGISTER_OPERATOR( \ + op_name, ops::ReduceOp##__VA_ARGS__, __##op_name##Maker__, \ + paddle::framework::EmptyGradOpMaker, \ + paddle::framework::EmptyGradOpMaker); diff --git a/paddle/fluid/operators/reduce_ops/reduce_sum_op.cc b/paddle/fluid/operators/reduce_ops/reduce_sum_op.cc index 14bb2cf0013a25239c0166e4abb8ca27645bf681..9949fd8a5bed6431006927e0c47d7ee08794eed1 100644 --- a/paddle/fluid/operators/reduce_ops/reduce_sum_op.cc +++ b/paddle/fluid/operators/reduce_ops/reduce_sum_op.cc @@ -21,18 +21,20 @@ namespace operators { // NOTE: Input(Out) is unnecessary in reduce_sum_grad, and Input(X) needs no // buffer -class ReduceSumOpGradDescMaker : public framework::SingleGradOpDescMaker { + +template +class ReduceSumOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("reduce_sum_grad"); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetAttrMap(Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetAttrMap(this->Attrs()); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); return op; } }; @@ -50,7 +52,8 @@ class ReduceSumOpMaker : public ops::ReduceOpMaker { }; REGISTER_OPERATOR(reduce_sum, ops::ReduceOp, ReduceSumOpMaker, - ops::ReduceSumOpGradDescMaker); + ops::ReduceSumOpGradMaker, + ops::ReduceSumOpGradMaker); REGISTER_OPERATOR(reduce_sum_grad, ops::ReduceGradOp, ops::ReduceSumGradNoNeedBufferVarInference); diff --git a/paddle/fluid/operators/reorder_lod_tensor_by_rank_op.cc b/paddle/fluid/operators/reorder_lod_tensor_by_rank_op.cc index b3b5038b0323363db06bc3739257781540f86d1c..32a7848d0edfd71ad40480e3437ddfe9efe278e5 100644 --- a/paddle/fluid/operators/reorder_lod_tensor_by_rank_op.cc +++ b/paddle/fluid/operators/reorder_lod_tensor_by_rank_op.cc @@ -211,19 +211,20 @@ class IdentityInferShape : public framework::InferShapeBase { } }; +template class ReorderLodTensorByRankGradOpMaker - : public framework::SingleGradOpDescMaker { + : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("reorder_lod_tensor_by_rank_grad"); - grad_op->SetInput("X", OutputGrad("Out")); - grad_op->SetOutput("Out", InputGrad("X")); - grad_op->SetInput("RankTable", Input("RankTable")); - return std::unique_ptr(grad_op); + grad_op->SetInput("X", this->OutputGrad("Out")); + grad_op->SetOutput("Out", this->InputGrad("X")); + grad_op->SetInput("RankTable", this->Input("RankTable")); + return std::unique_ptr(grad_op); } }; @@ -268,10 +269,10 @@ class ReorderLoDTensorByRankGradOp : public ReorderLoDTensorByRankTableBase { namespace ops = paddle::operators; -REGISTER_OPERATOR(reorder_lod_tensor_by_rank, - ops::ReorderLoDTensorByRankTableOp, - ops::ReorderLodTensorByRankGradOpMaker, - ops::ReorderLoDTensorByRankTableOpProtoMaker, - ops::IdentityInferShape); +REGISTER_OPERATOR( + reorder_lod_tensor_by_rank, ops::ReorderLoDTensorByRankTableOp, + ops::ReorderLodTensorByRankGradOpMaker, + ops::ReorderLodTensorByRankGradOpMaker, + ops::ReorderLoDTensorByRankTableOpProtoMaker, ops::IdentityInferShape); REGISTER_OPERATOR(reorder_lod_tensor_by_rank_grad, ops::ReorderLoDTensorByRankGradOp, ops::IdentityInferShape); diff --git a/paddle/fluid/operators/reshape_op.cc b/paddle/fluid/operators/reshape_op.cc index 9a32a02c11bf7af5b370b166631c641267a25818..df4fbb279f8435b729d54a65ad5e2b6a1448ed8c 100644 --- a/paddle/fluid/operators/reshape_op.cc +++ b/paddle/fluid/operators/reshape_op.cc @@ -421,37 +421,39 @@ class Reshape2OpMaker : public ReshapeOpMaker { } }; -class Reshape2GradMaker : public framework::SingleGradOpDescMaker { +template +class Reshape2GradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("reshape2_grad"); - grad_op->SetInput("XShape", Output("XShape")); - grad_op->SetInput("ShapeTensor", Input("ShapeTensor")); - grad_op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - grad_op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("XShape", this->Output("XShape")); + grad_op->SetInput("ShapeTensor", this->Input("ShapeTensor")); + grad_op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + grad_op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; -class Reshape2DoubleGradMaker : public framework::SingleGradOpDescMaker { +template +class Reshape2DoubleGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("reshape2_grad_grad"); - grad_op->SetInput("ShapeTensor", Input("ShapeTensor")); - grad_op->SetInput("DOut", Input(framework::GradVarName("Out"))); - grad_op->SetInput("DDX", OutputGrad(framework::GradVarName("X"))); + grad_op->SetInput("ShapeTensor", this->Input("ShapeTensor")); + grad_op->SetInput("DOut", this->Input(framework::GradVarName("Out"))); + grad_op->SetInput("DDX", this->OutputGrad(framework::GradVarName("X"))); - grad_op->SetOutput("DDOut", InputGrad(framework::GradVarName("Out"))); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetOutput("DDOut", this->InputGrad(framework::GradVarName("Out"))); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -540,9 +542,11 @@ DECLARE_INPLACE_OP_INFERER(ReshapeDoubleGradInplaceInToOut, {"DDX", "DDOut"}); namespace ops = paddle::operators; namespace plat = paddle::platform; -REGISTER_OPERATOR(reshape, ops::ReshapeOp, ops::ReshapeOpMaker, - paddle::framework::DefaultGradOpDescMaker, - ops::ReshapeOpInplaceInToOut); +REGISTER_OPERATOR( + reshape, ops::ReshapeOp, ops::ReshapeOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker, + ops::ReshapeOpInplaceInToOut); REGISTER_OPERATOR(reshape_grad, ops::ReshapeGradOp, ops::ReshapeGradInplaceInToOut); @@ -554,9 +558,13 @@ REGISTER_OP_CPU_KERNEL_FUNCTOR(reshape_grad, float, ops::ReshapeGradKernel, ops::ReshapeGradKernel, int64_t, ops::ReshapeGradKernel); REGISTER_OPERATOR(reshape2, ops::Reshape2Op, ops::Reshape2OpMaker, - ops::Reshape2GradMaker, ops::ReshapeOpInplaceInToOut); + ops::Reshape2GradMaker, + ops::Reshape2GradMaker, + ops::ReshapeOpInplaceInToOut); REGISTER_OPERATOR(reshape2_grad, ops::Reshape2GradOp, - ops::Reshape2DoubleGradMaker, ops::ReshapeGradInplaceInToOut); + ops::Reshape2DoubleGradMaker, + ops::Reshape2DoubleGradMaker, + ops::ReshapeGradInplaceInToOut); REGISTER_OPERATOR(reshape2_grad_grad, ops::Reshape2DoubleGradOp, ops::ReshapeDoubleGradInplaceInToOut); diff --git a/paddle/fluid/operators/reverse_op.cc b/paddle/fluid/operators/reverse_op.cc index a20f7d231fa9ea313581ac0629a87fa5f4a88ce5..1c3b3d3c2ff09dacf7c233a2f31f0e8830dc8e73 100644 --- a/paddle/fluid/operators/reverse_op.cc +++ b/paddle/fluid/operators/reverse_op.cc @@ -13,6 +13,7 @@ // limitations under the License. #include "paddle/fluid/operators/reverse_op.h" +#include #include namespace paddle { @@ -77,17 +78,18 @@ class ReverseOpMaker : public framework::OpProtoAndCheckerMaker { } }; -class ReverseGradMaker : public framework::SingleGradOpDescMaker { +template +class ReverseGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto* grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* grad_op = new T(); grad_op->SetType("reverse"); - grad_op->SetInput("X", OutputGrad("Out")); - grad_op->SetOutput("Out", InputGrad("X")); - grad_op->SetAttr("axis", GetAttr("axis")); - return std::unique_ptr(grad_op); + grad_op->SetInput("X", this->OutputGrad("Out")); + grad_op->SetOutput("Out", this->InputGrad("X")); + grad_op->SetAttr("axis", this->GetAttr("axis")); + return std::unique_ptr(grad_op); } }; @@ -96,7 +98,8 @@ class ReverseGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(reverse, ops::ReverseOp, ops::ReverseOpMaker, - ops::ReverseGradMaker); + ops::ReverseGradMaker, + ops::ReverseGradMaker); REGISTER_OPERATOR(reverse_grad, ops::ReverseOp); REGISTER_OP_CPU_KERNEL( reverse, ops::ReverseKernel, diff --git a/paddle/fluid/operators/rnn_memory_helper_op.cc b/paddle/fluid/operators/rnn_memory_helper_op.cc index f360ae3cbf4264f655a9d517708a4f9a1c1a15da..0ef8ae8b6a08d2d4f7771257147122f6f3c50e52 100644 --- a/paddle/fluid/operators/rnn_memory_helper_op.cc +++ b/paddle/fluid/operators/rnn_memory_helper_op.cc @@ -156,10 +156,12 @@ class RNNMemoryHelperGradOpShapeInference : public framework::InferShapeBase { } // namespace operators } // namespace paddle -REGISTER_OPERATOR(rnn_memory_helper, paddle::operators::RNNMemoryHelperOp, - paddle::operators::RNNMemoryHelperOpInfoMaker, - paddle::operators::RNNMemoryHelperOpShapeInference, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + rnn_memory_helper, paddle::operators::RNNMemoryHelperOp, + paddle::operators::RNNMemoryHelperOpInfoMaker, + paddle::operators::RNNMemoryHelperOpShapeInference, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(rnn_memory_helper_grad, paddle::operators::RNNMemoryHelperGradOp, paddle::operators::RNNMemoryHelperGradOpInfoMaker, diff --git a/paddle/fluid/operators/roi_align_op.cc b/paddle/fluid/operators/roi_align_op.cc index a57266690b01f4794d08b001d64f914e2badf1fa..f84639b7a6cea368daa57f3ae2a6a4267020e51e 100644 --- a/paddle/fluid/operators/roi_align_op.cc +++ b/paddle/fluid/operators/roi_align_op.cc @@ -153,19 +153,20 @@ Thus avoid the misaligned problem. } }; -class ROIAlignGradDescMaker : public framework::SingleGradOpDescMaker { +template +class ROIAlignGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("roi_align_grad"); - op->SetInput("X", Input("X")); - op->SetInput("ROIs", Input("ROIs")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("ROIs", this->Input("ROIs")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -177,7 +178,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(RoiAlignGradNoNeedBufVarsInferer, "X"); namespace ops = paddle::operators; REGISTER_OPERATOR(roi_align, ops::ROIAlignOp, ops::ROIAlignOpMaker, - ops::ROIAlignGradDescMaker); + ops::ROIAlignGradMaker, + ops::ROIAlignGradMaker); REGISTER_OPERATOR(roi_align_grad, ops::ROIAlignGradOp, ops::RoiAlignGradNoNeedBufVarsInferer); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/roi_pool_op.cc b/paddle/fluid/operators/roi_pool_op.cc index 0515768a630423f3bc062b3cac62f2d5907b9969..2b71ffc635fb4cd3654940014ef1ff13ee3f4d01 100644 --- a/paddle/fluid/operators/roi_pool_op.cc +++ b/paddle/fluid/operators/roi_pool_op.cc @@ -161,20 +161,21 @@ https://stackoverflow.com/questions/43430056/what-is-roi-layer-in-fast-rcnn } }; -class ROIPoolGradDescMaker : public framework::SingleGradOpDescMaker { +template +class ROIPoolGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("roi_pool_grad"); - op->SetInput("X", Input("X")); - op->SetInput("ROIs", Input("ROIs")); - op->SetInput("Argmax", Output("Argmax")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("ROIs", this->Input("ROIs")); + op->SetInput("Argmax", this->Output("Argmax")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -184,7 +185,8 @@ class ROIPoolGradDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(roi_pool, ops::ROIPoolOp, ops::ROIPoolOpMaker, - ops::ROIPoolGradDescMaker); + ops::ROIPoolGradMaker, + ops::ROIPoolGradMaker); REGISTER_OPERATOR(roi_pool_grad, ops::ROIPoolGradOp); REGISTER_OP_CPU_KERNEL( roi_pool, diff --git a/paddle/fluid/operators/row_conv_op.cc b/paddle/fluid/operators/row_conv_op.cc index d66b0a65fe0daf39a8d43fcc42bc5f8ce69d981a..dd85e4a12f560b66d3ec454260cae3a00d255171 100644 --- a/paddle/fluid/operators/row_conv_op.cc +++ b/paddle/fluid/operators/row_conv_op.cc @@ -320,20 +320,21 @@ class RowConvGradKernel } }; -class RowConvGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class RowConvGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("row_conv_grad"); - op->SetAttrMap(Attrs()); - op->SetInput("X", Input("X")); - op->SetInput("Filter", Input("Filter")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Filter"), InputGrad("Filter")); + op->SetAttrMap(this->Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Filter", this->Input("Filter")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Filter"), this->InputGrad("Filter")); return op; } }; @@ -343,7 +344,8 @@ class RowConvGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(row_conv, ops::RowConvOp, ops::RowConvOpMaker, - ops::RowConvGradOpDescMaker); + ops::RowConvGradOpMaker, + ops::RowConvGradOpMaker); REGISTER_OPERATOR(row_conv_grad, ops::RowConvGradOp); REGISTER_OP_CPU_KERNEL( row_conv, ops::RowConvKernel); diff --git a/paddle/fluid/operators/sample_logits_op.cc b/paddle/fluid/operators/sample_logits_op.cc index 962b5dbc50593768ad594d841d9646c9c6048b17..c0dfc94eedeb1479674ed7ea6b4ed54c98715ff1 100644 --- a/paddle/fluid/operators/sample_logits_op.cc +++ b/paddle/fluid/operators/sample_logits_op.cc @@ -210,22 +210,25 @@ class SampleLogitsOpGrad : public framework::OperatorWithKernel { }; // UNDERSTAND: what's the rule for making a GradMaker TODO -class SampleLogitsGradMaker : public framework::SingleGradOpDescMaker { + +template +class SampleLogitsGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* grad_op = new T(); grad_op->SetType("sample_logits_grad"); - grad_op->SetInput("LogitsDim", Output("LogitsDim")); - grad_op->SetInput("LabelsDim", Output("LabelsDim")); - grad_op->SetInput("Samples", Output("Samples")); + grad_op->SetInput("LogitsDim", this->Output("LogitsDim")); + grad_op->SetInput("LabelsDim", this->Output("LabelsDim")); + grad_op->SetInput("Samples", this->Output("Samples")); grad_op->SetInput(framework::GradVarName("SampledLogits"), - OutputGrad("SampledLogits")); - grad_op->SetOutput(framework::GradVarName("Logits"), InputGrad("Logits")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + this->OutputGrad("SampledLogits")); + grad_op->SetOutput(framework::GradVarName("Logits"), + this->InputGrad("Logits")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -235,7 +238,8 @@ class SampleLogitsGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(sample_logits, ops::SampleLogitsOp, ops::SampleLogitsOpMaker, - ops::SampleLogitsGradMaker); + ops::SampleLogitsGradMaker, + ops::SampleLogitsGradMaker); REGISTER_OPERATOR(sample_logits_grad, ops::SampleLogitsOpGrad); REGISTER_OP_CPU_KERNEL(sample_logits, ops::SampleLogitsKernel, ops::SampleLogitsKernel); diff --git a/paddle/fluid/operators/sampling_id_op.cc b/paddle/fluid/operators/sampling_id_op.cc index ece3ff6e7051bfb8974e0853ce84f97e01fd95dc..bf0739557bcda4a0b953f43df086b404b6fbe41b 100644 --- a/paddle/fluid/operators/sampling_id_op.cc +++ b/paddle/fluid/operators/sampling_id_op.cc @@ -70,8 +70,10 @@ A layer for sampling id from multinomial distribution from the } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(sampling_id, ops::SamplingIdOp, ops::SamplingIdOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + sampling_id, ops::SamplingIdOp, ops::SamplingIdOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(sampling_id, paddle::operators::SamplingIdKernel, paddle::operators::SamplingIdKernel); diff --git a/paddle/fluid/operators/scale_op.cc b/paddle/fluid/operators/scale_op.cc index 383e7940fa56586d17cf8819c463c201fbd24050..e055962f50543920c2f99847198573f7f9f3826f 100644 --- a/paddle/fluid/operators/scale_op.cc +++ b/paddle/fluid/operators/scale_op.cc @@ -81,19 +81,20 @@ class ScaleOpVarTypeInference : public framework::VarTypeInference { } }; -class ScaleGradMaker : public framework::SingleGradOpDescMaker { +template +class ScaleGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("scale"); - grad_op->SetInput("X", OutputGrad("Out")); - grad_op->SetOutput("Out", InputGrad("X")); - grad_op->SetAttr("scale", GetAttr("scale")); + grad_op->SetInput("X", this->OutputGrad("Out")); + grad_op->SetOutput("Out", this->InputGrad("X")); + grad_op->SetAttr("scale", this->GetAttr("scale")); grad_op->SetAttr("bias", 0.0f); grad_op->SetAttr("bias_after_scale", true); - return std::unique_ptr(grad_op); + return std::unique_ptr(grad_op); } }; @@ -103,7 +104,9 @@ using ScaleOpInplace = framework::SingleOpInplaceInToOut; namespace ops = paddle::operators; -REGISTER_OPERATOR(scale, ops::ScaleOp, ops::ScaleOpMaker, ops::ScaleGradMaker, +REGISTER_OPERATOR(scale, ops::ScaleOp, ops::ScaleOpMaker, + ops::ScaleGradMaker, + ops::ScaleGradMaker, ops::ScaleOpVarTypeInference, ops::ScaleOpInplace); REGISTER_OP_CPU_KERNEL( scale, ops::ScaleKernel, diff --git a/paddle/fluid/operators/scatter_nd_add_op.cc b/paddle/fluid/operators/scatter_nd_add_op.cc index ba65832dceaee53fbda209527c0824f51b282627..e86724dd569199ecb87f52ea29268bfc68ed5957 100644 --- a/paddle/fluid/operators/scatter_nd_add_op.cc +++ b/paddle/fluid/operators/scatter_nd_add_op.cc @@ -140,20 +140,22 @@ Output is obtained by applying sparse addition to a single value or slice in a V } }; -class ScatterNdAddGradDescMaker : public framework::SingleGradOpDescMaker { +template +class ScatterNdAddGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("scatter_nd_add_grad"); - op->SetInput("Index", Input("Index")); - op->SetInput("Updates", Input("Updates")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Updates"), InputGrad("Updates")); - op->SetAttrMap(Attrs()); + op->SetInput("Index", this->Input("Index")); + op->SetInput("Updates", this->Input("Updates")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Updates"), + this->InputGrad("Updates")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -167,7 +169,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(ScatterNdAddGradNoNeedBufferVarsInference, namespace ops = paddle::operators; REGISTER_OPERATOR(scatter_nd_add, ops::ScatterNdAddOp, ops::ScatterNdAddOpMaker, - ops::ScatterNdAddGradDescMaker); + ops::ScatterNdAddGradMaker, + ops::ScatterNdAddGradMaker); REGISTER_OPERATOR(scatter_nd_add_grad, ops::ScatterNdAddGradOp, ops::ScatterNdAddGradNoNeedBufferVarsInference); diff --git a/paddle/fluid/operators/scatter_op.cc b/paddle/fluid/operators/scatter_op.cc index b3f43a28dffd7d0f0d41a57619b78283bee7f02f..d763f74d4ee6e66b8ec6de5d3e0c11679c664687 100644 --- a/paddle/fluid/operators/scatter_op.cc +++ b/paddle/fluid/operators/scatter_op.cc @@ -107,20 +107,22 @@ $$ } }; -class ScatterGradDescMaker : public framework::SingleGradOpDescMaker { +template +class ScatterGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("scatter_grad"); - op->SetInput("Ids", Input("Ids")); - op->SetInput("Updates", Input("Updates")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Updates"), InputGrad("Updates")); - op->SetAttrMap(Attrs()); + op->SetInput("Ids", this->Input("Ids")); + op->SetInput("Updates", this->Input("Updates")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Updates"), + this->InputGrad("Updates")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -133,7 +135,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(ScatterGradNoNeedBufferVarsInference, namespace ops = paddle::operators; REGISTER_OPERATOR(scatter, ops::ScatterOp, ops::ScatterOpMaker, - ops::ScatterGradDescMaker); + ops::ScatterGradMaker, + ops::ScatterGradMaker); REGISTER_OPERATOR(scatter_grad, ops::ScatterGradOp, ops::ScatterGradNoNeedBufferVarsInference); REGISTER_OP_CPU_KERNEL(scatter, ops::ScatterOpKernel); diff --git a/paddle/fluid/operators/selu_op.cc b/paddle/fluid/operators/selu_op.cc index f71d844d9e9a21b1f494dbf648a3622b9aff5ec6..09550efefebdf62cc44212959962a291e8126019 100644 --- a/paddle/fluid/operators/selu_op.cc +++ b/paddle/fluid/operators/selu_op.cc @@ -13,7 +13,6 @@ See the License for the specific language governing permissions and limitations under the License. */ #include "paddle/fluid/operators/selu_op.h" - #include #include #include @@ -87,18 +86,19 @@ or not. And the output shares the LoD information with input `X`. } }; -class SeluGradMaker : public framework::SingleGradOpDescMaker { +template +class SeluGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("selu_grad"); - grad_op->SetInput("Out", Output("Out")); - grad_op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - grad_op->SetOutput(framework::GradVarName("X"), InputGrad("X")); + grad_op->SetInput("Out", this->Output("Out")); + grad_op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + grad_op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); grad_op->SetAttrMap(this->Attrs()); - return std::unique_ptr(grad_op); + return std::unique_ptr(grad_op); } }; @@ -128,7 +128,8 @@ class SeluGradOp : public framework::OperatorWithKernel { namespace ops = paddle::operators; REGISTER_OPERATOR(selu, ops::SeluOp, ops::SeluOpMaker, ops::SeluOpInferVarType, - ops::SeluGradMaker); + ops::SeluGradMaker, + ops::SeluGradMaker); REGISTER_OPERATOR(selu_grad, ops::SeluGradOp); REGISTER_OP_CPU_KERNEL( selu, ops::SeluKernel, diff --git a/paddle/fluid/operators/sequence_ops/sequence_concat_op.cc b/paddle/fluid/operators/sequence_ops/sequence_concat_op.cc index 118c8ce0b1145dfc42e11d7fc91888e92d84b4c6..319fdec06ac82a2352940767852e160eee6580c7 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_concat_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_concat_op.cc @@ -74,18 +74,19 @@ class SeqConcatShapeInferer : public framework::InferShapeBase { } }; -class SeqConcatGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class SeqConcatGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("sequence_concat_grad"); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X", false)); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X", false)); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -118,7 +119,8 @@ namespace op = paddle::operators; REGISTER_OPERATOR(sequence_concat, paddle::framework::OperatorWithKernel, op::SeqConcatOpMaker, op::SeqConcatShapeInferer, - op::SeqConcatGradOpDescMaker); + op::SeqConcatGradOpMaker, + op::SeqConcatGradOpMaker); template using Kernel = op::SeqConcatKernel; REGISTER_OP_CPU_KERNEL(sequence_concat, Kernel, Kernel, diff --git a/paddle/fluid/operators/sequence_ops/sequence_conv_op.cc b/paddle/fluid/operators/sequence_ops/sequence_conv_op.cc index 89c1fe834832802cc86dacd5a2d8c22bafa6072b..ce731c99b5ba0fb2115c4b1f3936672191c514b9 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_conv_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_conv_op.cc @@ -174,29 +174,31 @@ context_length, context_stride and context_start. } }; -class SequenceConvGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class SequenceConvGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("sequence_conv_grad"); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - if (boost::get(Attrs().at("paddingTrainable")) && - ForwardOp().Inputs().count("PaddingData") > 0) { - op->SetInput("PaddingData", Input("PaddingData")); + if (op->HasAttr("paddingTrainable") && + boost::get(op->GetAttr("paddingTrainable")) && + this->HasInput("PaddingData")) { + op->SetInput("PaddingData", this->Input("PaddingData")); op->SetOutput(framework::GradVarName("PaddingData"), - InputGrad("PaddingData")); + this->InputGrad("PaddingData")); } - op->SetInput("X", Input("X")); - op->SetInput("Filter", Input("Filter")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); + op->SetInput("X", this->Input("X")); + op->SetInput("Filter", this->Input("Filter")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Filter"), InputGrad("Filter")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Filter"), this->InputGrad("Filter")); return op; } @@ -221,7 +223,8 @@ class SequenceConvGradNoNeedBufferVarsInference namespace ops = paddle::operators; REGISTER_OPERATOR(sequence_conv, ops::SequenceConvOp, ops::SequenceConvOpMaker, - ops::SequenceConvGradOpDescMaker); + ops::SequenceConvGradOpMaker, + ops::SequenceConvGradOpMaker); REGISTER_OPERATOR(sequence_conv_grad, ops::SequenceConvGradOp, ops::SequenceConvGradNoNeedBufferVarsInference); diff --git a/paddle/fluid/operators/sequence_ops/sequence_expand_as_op.cc b/paddle/fluid/operators/sequence_ops/sequence_expand_as_op.cc index c7284d0950c295b576af7a692d2db2f6388c2fd4..944ca37c7fa55492906c82648816691d41185a54 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_expand_as_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_expand_as_op.cc @@ -159,20 +159,20 @@ class SequenceExpandAsOpGrad : public framework::OperatorWithKernel { } }; -class SequenceExpandAsOpGradOpDescMaker - : public framework::SingleGradOpDescMaker { +template +class SequenceExpandAsOpGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("sequence_expand_as_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Y", Input("Y")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Y", this->Input("Y")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -186,10 +186,11 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE( } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(sequence_expand_as, ops::SequenceExpandAsOp, - ops::SequenceExpandAsOpMaker, - ops::SequenceExpandAsOpGradOpDescMaker, - ops::SequenceExpandAsOpNoNeedBufferVarsInference); +REGISTER_OPERATOR( + sequence_expand_as, ops::SequenceExpandAsOp, ops::SequenceExpandAsOpMaker, + ops::SequenceExpandAsOpGradOpMaker, + ops::SequenceExpandAsOpGradOpMaker, + ops::SequenceExpandAsOpNoNeedBufferVarsInference); REGISTER_OPERATOR(sequence_expand_as_grad, ops::SequenceExpandAsOpGrad, ops::SequenceExpandAsGradOpNoNeedBufferVarsInference); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/sequence_ops/sequence_expand_op.cc b/paddle/fluid/operators/sequence_ops/sequence_expand_op.cc index 90f794ab5ff37780e4cc451f4c0f3bbd5e06561b..3ddbebcd6af960b0f3f566e8e8bd074fd8cc3f73 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_expand_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_expand_op.cc @@ -214,19 +214,20 @@ class SequenceExpandOpGrad : public framework::OperatorWithKernel { } }; -class SequenceExpandOpGradDescMaker : public framework::SingleGradOpDescMaker { +template +class SequenceExpandOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("sequence_expand_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Y", Input("Y")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Y", this->Input("Y")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -242,7 +243,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE( namespace ops = paddle::operators; REGISTER_OPERATOR(sequence_expand, ops::SequenceExpandOp, ops::SequenceExpandOpMaker, - ops::SequenceExpandOpGradDescMaker, + ops::SequenceExpandOpGradMaker, + ops::SequenceExpandOpGradMaker, ops::SequenceExpandOpNoNeedBufferVarsInference); REGISTER_OPERATOR(sequence_expand_grad, ops::SequenceExpandOpGrad, ops::SequenceExpandGradOpNoNeedBufferVarsInference); diff --git a/paddle/fluid/operators/sequence_ops/sequence_mask_op.cc b/paddle/fluid/operators/sequence_ops/sequence_mask_op.cc index cd0170dd1b4c64fdf8b81bb15c41feae6e95af47..e9097ee258a90bb678ee3d326504d42b2eb6d1f7 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_mask_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_mask_op.cc @@ -89,9 +89,11 @@ If maxlen < 0, maxlen = max(X) } // namespace operators } // namespace paddle -REGISTER_OPERATOR(sequence_mask, paddle::operators::SequenceMaskOp, - paddle::operators::SequenceMaskOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + sequence_mask, paddle::operators::SequenceMaskOp, + paddle::operators::SequenceMaskOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL( sequence_mask, diff --git a/paddle/fluid/operators/sequence_ops/sequence_pad_op.cc b/paddle/fluid/operators/sequence_ops/sequence_pad_op.cc index de5a0aa45bc3698e29c86c3a5aa00cfa8978c269..65b8839a2b1e8962132d89f3299798a8ad64e26b 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_pad_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_pad_op.cc @@ -205,18 +205,19 @@ class SequencePadGradOp : public framework::OperatorWithKernel { } }; -class SequencePadGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class SequencePadGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("sequence_pad_grad"); - op->SetAttrMap(Attrs()); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); + op->SetAttrMap(this->Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); return op; } }; @@ -229,7 +230,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE( namespace ops = paddle::operators; REGISTER_OPERATOR(sequence_pad, ops::SequencePadOp, ops::SequencePadOpMaker, - ops::SequencePadGradOpDescMaker); + ops::SequencePadGradOpMaker, + ops::SequencePadGradOpMaker); REGISTER_OPERATOR(sequence_pad_grad, ops::SequencePadGradOp, ops::SequencePadGradOpNoNeedBufferVarsInference); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/sequence_ops/sequence_pool_op.cc b/paddle/fluid/operators/sequence_ops/sequence_pool_op.cc index bf82044ad472dadae237b39c9a48f16b11701475..d2459570c92228f56f6649a25b41a3a9b3ab3695 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_pool_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_pool_op.cc @@ -138,22 +138,24 @@ class SequencePoolGradOp : public framework::OperatorWithKernel { } }; -class SequencePoolGradOpMaker : public framework::SingleGradOpDescMaker { +template +class SequencePoolGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* op_desc_ptr = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op_desc_ptr = new T(); op_desc_ptr->SetType("sequence_pool_grad"); - op_desc_ptr->SetInput("X", Input("X")); - if (boost::get(GetAttr("pooltype")) == "MAX") { - op_desc_ptr->SetInput("MaxIndex", Output("MaxIndex")); + op_desc_ptr->SetInput("X", this->Input("X")); + if (boost::get(this->GetAttr("pooltype")) == "MAX") { + op_desc_ptr->SetInput("MaxIndex", this->Output("MaxIndex")); } - op_desc_ptr->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op_desc_ptr->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op_desc_ptr->SetAttrMap(Attrs()); - return std::unique_ptr(op_desc_ptr); + op_desc_ptr->SetInput(framework::GradVarName("Out"), + this->OutputGrad("Out")); + op_desc_ptr->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op_desc_ptr->SetAttrMap(this->Attrs()); + return std::unique_ptr(op_desc_ptr); } }; @@ -165,7 +167,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE( namespace ops = paddle::operators; REGISTER_OPERATOR(sequence_pool, ops::SequencePoolOp, ops::SequencePoolOpMaker, - ops::SequencePoolGradOpMaker); + ops::SequencePoolGradOpMaker, + ops::SequencePoolGradOpMaker); REGISTER_OPERATOR(sequence_pool_grad, ops::SequencePoolGradOp, ops::SequencePoolGradOpNoNeedBufferVarsInference); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/sequence_ops/sequence_reshape_op.cc b/paddle/fluid/operators/sequence_ops/sequence_reshape_op.cc index 5421f35662b3b0a6a61748ac0b6b5f718d213b73..e1d8911c32ffc56209b1b59805d10f59f24dd25f 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_reshape_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_reshape_op.cc @@ -13,6 +13,7 @@ // limitations under the License. #include "paddle/fluid/operators/sequence_ops/sequence_reshape_op.h" +#include #include "paddle/fluid/framework/ddim.h" namespace paddle { @@ -97,19 +98,21 @@ class SequenceReshapeGradOp : public framework::OperatorWithKernel { } }; -class SequenceReshapeGradOpMaker : public framework::SingleGradOpDescMaker { +template +class SequenceReshapeGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* op_desc_ptr = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op_desc_ptr = new T(); op_desc_ptr->SetType("sequence_reshape_grad"); - op_desc_ptr->SetInput("X", Input("X")); - op_desc_ptr->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op_desc_ptr->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op_desc_ptr->SetAttrMap(Attrs()); - return std::unique_ptr(op_desc_ptr); + op_desc_ptr->SetInput("X", this->Input("X")); + op_desc_ptr->SetInput(framework::GradVarName("Out"), + this->OutputGrad("Out")); + op_desc_ptr->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op_desc_ptr->SetAttrMap(this->Attrs()); + return std::unique_ptr(op_desc_ptr); } }; @@ -118,7 +121,9 @@ class SequenceReshapeGradOpMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(sequence_reshape, ops::SequenceReshapeOp, - ops::SequenceReshapeOpMaker, ops::SequenceReshapeGradOpMaker); + ops::SequenceReshapeOpMaker, + ops::SequenceReshapeGradOpMaker, + ops::SequenceReshapeGradOpMaker); REGISTER_OPERATOR(sequence_reshape_grad, ops::SequenceReshapeGradOp); REGISTER_OP_CPU_KERNEL( sequence_reshape, diff --git a/paddle/fluid/operators/sequence_ops/sequence_reverse_op.cc b/paddle/fluid/operators/sequence_ops/sequence_reverse_op.cc index dfbbf5f156983189ac1ab82fbff51d7eb4844f9a..739b26b0e3e5069eb114e2ab034e1a989f9768a2 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_reverse_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_reverse_op.cc @@ -18,7 +18,8 @@ namespace ops = paddle::operators; REGISTER_OPERATOR(sequence_reverse, ops::SequenceReverseOp, ops::SequenceReverseOpMaker, - ops::SequenceReverseGradOpDescMaker); + ops::SequenceReverseGradOpMaker, + ops::SequenceReverseGradOpMaker); REGISTER_OP_CPU_KERNEL( sequence_reverse, diff --git a/paddle/fluid/operators/sequence_ops/sequence_reverse_op.h b/paddle/fluid/operators/sequence_ops/sequence_reverse_op.h index 12d0f8095ee792d9433e020ad25831281529865f..d0078c0321df92be9ba4f5c0bc2dee84795e0bc0 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_reverse_op.h +++ b/paddle/fluid/operators/sequence_ops/sequence_reverse_op.h @@ -155,17 +155,18 @@ class SequenceReverseOpKernel : public framework::OpKernel { } }; -class SequenceReverseGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class SequenceReverseGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("sequence_reverse"); - op->SetInput("X", OutputGrad("Y")); - op->SetOutput("Y", InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->OutputGrad("Y")); + op->SetOutput("Y", this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; diff --git a/paddle/fluid/operators/sequence_ops/sequence_scatter_op.cc b/paddle/fluid/operators/sequence_ops/sequence_scatter_op.cc index 7f9dbbf7ecae611946bb7c0e488a8614c030c97d..0700077ac69709d5493a5df6a901bcc572f252bc 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_scatter_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_scatter_op.cc @@ -139,20 +139,22 @@ class SequenceScatterGradOp : public framework::OperatorWithKernel { } }; -class SequenceScatterGradDescMaker : public framework::SingleGradOpDescMaker { +template +class SequenceScatterGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("sequence_scatter_grad"); - op->SetInput("Ids", Input("Ids")); - op->SetInput("Updates", Input("Updates")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Updates"), InputGrad("Updates")); - op->SetAttrMap(Attrs()); + op->SetInput("Ids", this->Input("Ids")); + op->SetInput("Updates", this->Input("Updates")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Updates"), + this->InputGrad("Updates")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -166,7 +168,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE( namespace ops = paddle::operators; REGISTER_OPERATOR(sequence_scatter, ops::SequenceScatterOp, ops::SequenceScatterOpMaker, - ops::SequenceScatterGradDescMaker); + ops::SequenceScatterGradMaker, + ops::SequenceScatterGradMaker); REGISTER_OPERATOR(sequence_scatter_grad, ops::SequenceScatterGradOp, ops::SequenceScatterGradNoNeedBufferVarsInference); REGISTER_OP_CPU_KERNEL(sequence_scatter, ops::SequenceScatterOpKernel, diff --git a/paddle/fluid/operators/sequence_ops/sequence_slice_op.cc b/paddle/fluid/operators/sequence_ops/sequence_slice_op.cc index 537184d8b521d2f9f5d7d2d0e9358e98e77467fb..9e31a81c4353ea8622c258fc5cc4d89eabee4f28 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_slice_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_slice_op.cc @@ -116,20 +116,21 @@ NOTE: The first dimension size of input, the size of offset and Length, should b } }; -class SequenceSliceGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class SequenceSliceGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("sequence_slice_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Offset", Input("Offset")); - op->SetInput("Length", Input("Length")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Offset", this->Input("Offset")); + op->SetInput("Length", this->Input("Length")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -142,7 +143,9 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE( namespace ops = paddle::operators; REGISTER_OPERATOR(sequence_slice, ops::SequenceSliceOp, - ops::SequenceSliceOpMaker, ops::SequenceSliceGradOpDescMaker); + ops::SequenceSliceOpMaker, + ops::SequenceSliceGradOpMaker, + ops::SequenceSliceGradOpMaker); REGISTER_OPERATOR(sequence_slice_grad, ops::SequenceSliceGradOp, ops::SequenceSliceGradNoNeedBufferVarsInference); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/sequence_ops/sequence_softmax_op.cc b/paddle/fluid/operators/sequence_ops/sequence_softmax_op.cc index 12729f432478bc514d654c1ade5484ae979b681d..33ad5d828b7c6051f1242b6751dbf7402fd52afc 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_softmax_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_softmax_op.cc @@ -158,9 +158,10 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE( } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(sequence_softmax, ops::SequenceSoftmaxOp, - ops::SequenceSoftmaxOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + sequence_softmax, ops::SequenceSoftmaxOp, ops::SequenceSoftmaxOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(sequence_softmax_grad, ops::SequenceSoftmaxGradOp, ops::SequenceSoftmaxGradOpNoNeedBufferVarsInferer); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/sequence_ops/sequence_topk_avg_pooling_op.cc b/paddle/fluid/operators/sequence_ops/sequence_topk_avg_pooling_op.cc index 06b16152ef9f0d0c92151a0c4f372360fe948e3b..b442c41eed16c49641ef47dc48c3a50316813c2e 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_topk_avg_pooling_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_topk_avg_pooling_op.cc @@ -95,31 +95,35 @@ class SequenceTopkAvgPoolingGradOp : public framework::OperatorWithKernel { } }; -class SequenceTopkAvgPoolGradOpMaker : public framework::SingleGradOpDescMaker { +template +class SequenceTopkAvgPoolGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* op_desc_ptr = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op_desc_ptr = new T(); op_desc_ptr->SetType("sequence_topk_avg_pooling_grad"); - op_desc_ptr->SetInput("X", Input("X")); - op_desc_ptr->SetInput("ROW", Input("ROW")); - op_desc_ptr->SetInput("COLUMN", Input("COLUMN")); - op_desc_ptr->SetInput("pos", Output("pos")); - op_desc_ptr->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op_desc_ptr->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op_desc_ptr->SetAttrMap(Attrs()); - return std::unique_ptr(op_desc_ptr); + op_desc_ptr->SetInput("X", this->Input("X")); + op_desc_ptr->SetInput("ROW", this->Input("ROW")); + op_desc_ptr->SetInput("COLUMN", this->Input("COLUMN")); + op_desc_ptr->SetInput("pos", this->Output("pos")); + op_desc_ptr->SetInput(framework::GradVarName("Out"), + this->OutputGrad("Out")); + op_desc_ptr->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op_desc_ptr->SetAttrMap(this->Attrs()); + return std::unique_ptr(op_desc_ptr); } }; } // namespace operators } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(sequence_topk_avg_pooling, ops::SequenceTopkAvgPoolingOp, - ops::SequenceTopkAvgPoolingOpMaker, - ops::SequenceTopkAvgPoolGradOpMaker); +REGISTER_OPERATOR( + sequence_topk_avg_pooling, ops::SequenceTopkAvgPoolingOp, + ops::SequenceTopkAvgPoolingOpMaker, + ops::SequenceTopkAvgPoolGradOpMaker, + ops::SequenceTopkAvgPoolGradOpMaker); REGISTER_OPERATOR(sequence_topk_avg_pooling_grad, ops::SequenceTopkAvgPoolingGradOp); REGISTER_OP_CPU_KERNEL(sequence_topk_avg_pooling, diff --git a/paddle/fluid/operators/sequence_ops/sequence_unpad_op.cc b/paddle/fluid/operators/sequence_ops/sequence_unpad_op.cc index 558d180cfba276c355c74b8153bbc28597a1210a..dbb01a5c36722ea442489d3657001e51d036fd83 100644 --- a/paddle/fluid/operators/sequence_ops/sequence_unpad_op.cc +++ b/paddle/fluid/operators/sequence_ops/sequence_unpad_op.cc @@ -138,18 +138,19 @@ class SequenceUnpadGradOp : public framework::OperatorWithKernel { } }; -class SequenceUnpadGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class SequenceUnpadGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("sequence_unpad_grad"); - op->SetAttrMap(Attrs()); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); + op->SetAttrMap(this->Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); return op; } }; @@ -162,7 +163,9 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE( namespace ops = paddle::operators; REGISTER_OPERATOR(sequence_unpad, ops::SequenceUnpadOp, - ops::SequenceUnpadOpMaker, ops::SequenceUnpadGradOpDescMaker); + ops::SequenceUnpadOpMaker, + ops::SequenceUnpadGradOpMaker, + ops::SequenceUnpadGradOpMaker); REGISTER_OPERATOR(sequence_unpad_grad, ops::SequenceUnpadGradOp, ops::SequenceUnpadGradOpNoNeedBufferVarsInference); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/shape_op.cc b/paddle/fluid/operators/shape_op.cc index 3715dd114d6363ca48a0ef6a4c162b1ce4486f55..4a0f41ae54d768a71dd883efc020f1674bcef89f 100644 --- a/paddle/fluid/operators/shape_op.cc +++ b/paddle/fluid/operators/shape_op.cc @@ -52,8 +52,10 @@ Return the shape of the input. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(shape, ops::ShapeOp, ops::ShapeOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + shape, ops::ShapeOp, ops::ShapeOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(shape, ops::ShapeKernel, ops::ShapeKernel, ops::ShapeKernel, ops::ShapeKernel, ops::ShapeKernel); diff --git a/paddle/fluid/operators/shrink_rnn_memory_op.cc b/paddle/fluid/operators/shrink_rnn_memory_op.cc index 586a65091df1816b67b045ebcf33009d5daac0e7..c9b0795ddb0bf5764a4ca20c5d26445affc257ec 100644 --- a/paddle/fluid/operators/shrink_rnn_memory_op.cc +++ b/paddle/fluid/operators/shrink_rnn_memory_op.cc @@ -162,19 +162,20 @@ class ShrinkRNNMemoryGradInferShape : public framework::InferShapeBase { } }; -class ShrinkRNNGradOpMaker : public framework::SingleGradOpDescMaker { +template +class ShrinkRNNGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *op = new T(); op->SetType("shrink_rnn_memory_grad"); - op->SetInput("X", Input("X")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); - return std::unique_ptr(op); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); + return std::unique_ptr(op); } }; @@ -184,6 +185,8 @@ class ShrinkRNNGradOpMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(shrink_rnn_memory, ops::ShrinkRNNMemoryOp, ops::ShrinkRNNMemoryInferShape, - ops::ShrinkRNNMemoryOpProtoMaker, ops::ShrinkRNNGradOpMaker); + ops::ShrinkRNNMemoryOpProtoMaker, + ops::ShrinkRNNGradOpMaker, + ops::ShrinkRNNGradOpMaker); REGISTER_OPERATOR(shrink_rnn_memory_grad, ops::ShrinkRNNMemoryGradOp, ops::ShrinkRNNMemoryGradInferShape); diff --git a/paddle/fluid/operators/shuffle_channel_op.cc b/paddle/fluid/operators/shuffle_channel_op.cc index 48da765416f6d47b7eaad8c869acbc31a1329f2e..5540428ba5f6710fe4f9c49ef6087de2eedf2a6f 100644 --- a/paddle/fluid/operators/shuffle_channel_op.cc +++ b/paddle/fluid/operators/shuffle_channel_op.cc @@ -90,17 +90,18 @@ class ShuffleChannelGradOp : public framework::OperatorWithKernel { } }; -class ShuffleChannelGradDescMaker : public framework::SingleGradOpDescMaker { +template +class ShuffleChannelGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("shuffle_channel_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -110,7 +111,9 @@ class ShuffleChannelGradDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(shuffle_channel, ops::ShuffleChannelOp, - ops::ShuffleChannelOpMaker, ops::ShuffleChannelGradDescMaker); + ops::ShuffleChannelOpMaker, + ops::ShuffleChannelGradMaker, + ops::ShuffleChannelGradMaker); REGISTER_OPERATOR(shuffle_channel_grad, ops::ShuffleChannelGradOp); diff --git a/paddle/fluid/operators/sigmoid_cross_entropy_with_logits_op.cc b/paddle/fluid/operators/sigmoid_cross_entropy_with_logits_op.cc index c453b03dddf68a7f4638aa0eceaa2aa70dc3d5f4..a4ef2a2369af410cd56ae2cba32a55b8ab665ab4 100644 --- a/paddle/fluid/operators/sigmoid_cross_entropy_with_logits_op.cc +++ b/paddle/fluid/operators/sigmoid_cross_entropy_with_logits_op.cc @@ -150,20 +150,21 @@ However the output only shares the LoD with input `X`. } }; -class SigmoidCrossEntropyWithLogitsGradOpDescMaker - : public framework::SingleGradOpDescMaker { +template +class SigmoidCrossEntropyWithLogitsGradOpMaker + : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("sigmoid_cross_entropy_with_logits_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Label", Input("Label")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput("X", this->Input("X")); + op->SetInput("Label", this->Input("Label")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -178,11 +179,12 @@ DECLARE_INPLACE_OP_INFERER(SigmoidCrossEntropyWithLogitsGradInplaceInferer, } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(sigmoid_cross_entropy_with_logits, - ops::SigmoidCrossEntropyWithLogitsOp, - ops::SigmoidCrossEntropyWithLogitsOpMaker, - ops::SigmoidCrossEntropyWithLogitsGradOpDescMaker, - ops::SigmoidCrossEntropyWithLogitsInplaceInferer); +REGISTER_OPERATOR( + sigmoid_cross_entropy_with_logits, ops::SigmoidCrossEntropyWithLogitsOp, + ops::SigmoidCrossEntropyWithLogitsOpMaker, + ops::SigmoidCrossEntropyWithLogitsGradOpMaker, + ops::SigmoidCrossEntropyWithLogitsGradOpMaker, + ops::SigmoidCrossEntropyWithLogitsInplaceInferer); REGISTER_OPERATOR(sigmoid_cross_entropy_with_logits_grad, ops::SigmoidCrossEntropyWithLogitsGradOp, ops::SigmoidCrossEntropyWithLogitsGradInplaceInferer); diff --git a/paddle/fluid/operators/sign_op.cc b/paddle/fluid/operators/sign_op.cc index 6837856a6da804e27af2cd6c83052c04f17140d8..3793a3d43fe4c024e760e15debf3ea0bbd813e3c 100644 --- a/paddle/fluid/operators/sign_op.cc +++ b/paddle/fluid/operators/sign_op.cc @@ -13,6 +13,7 @@ See the License for the specific language governing permissions and limitations under the License. */ #include "paddle/fluid/operators/sign_op.h" +#include namespace paddle { namespace operators { @@ -45,17 +46,18 @@ $$Out = X.sign()$$ } }; -class SignGradMaker : public framework::SingleGradOpDescMaker { +template +class SignGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("scale"); - grad_op->SetInput("X", OutputGrad("Out")); - grad_op->SetOutput("Out", InputGrad("X")); + grad_op->SetInput("X", this->OutputGrad("Out")); + grad_op->SetOutput("Out", this->InputGrad("X")); grad_op->SetAttr("scale", 0.0f); - return std::unique_ptr(grad_op); + return std::unique_ptr(grad_op); } }; @@ -65,7 +67,8 @@ class SignGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(sign, ops::SignOp, ops::SignOpMaker, - ops::SignGradMaker); + ops::SignGradMaker, + ops::SignGradMaker); REGISTER_OP_CPU_KERNEL( sign, ops::SignKernel, ops::SignKernel); diff --git a/paddle/fluid/operators/similarity_focus_op.cc b/paddle/fluid/operators/similarity_focus_op.cc index e49ce7c487225f6e8e077ba32e1da2b759879b1e..3e3c9cf98fd7eb2d3bdbc0e90c95bb15abdd5b76 100644 --- a/paddle/fluid/operators/similarity_focus_op.cc +++ b/paddle/fluid/operators/similarity_focus_op.cc @@ -80,8 +80,9 @@ class SimilarityFocusOp : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(similarity_focus, ops::SimilarityFocusOp, - ops::SimilarityFocusOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + similarity_focus, ops::SimilarityFocusOp, ops::SimilarityFocusOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(similarity_focus, ops::SimilarityFocusKernel, ops::SimilarityFocusKernel); diff --git a/paddle/fluid/operators/size_op.cc b/paddle/fluid/operators/size_op.cc index 0eda6fbef324111ec902b5695750e910b3aad792..ca7f36205a24a38cb7b295404217ffc4c495f2a8 100644 --- a/paddle/fluid/operators/size_op.cc +++ b/paddle/fluid/operators/size_op.cc @@ -50,8 +50,10 @@ Return the number of elements in the input. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(size, ops::SizeOp, ops::SizeOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + size, ops::SizeOp, ops::SizeOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(size, ops::SizeKernel, ops::SizeKernel, ops::SizeKernel, ops::SizeKernel, ops::SizeKernel); diff --git a/paddle/fluid/operators/slice_op.cc b/paddle/fluid/operators/slice_op.cc index 9adb4de01cb6802eafb3b975fafa6a7f7c91d8e1..4caa07dff87a6e32723f86efdd4e706b70b152b8 100644 --- a/paddle/fluid/operators/slice_op.cc +++ b/paddle/fluid/operators/slice_op.cc @@ -262,23 +262,24 @@ class SliceOpGrad : public framework::OperatorWithKernel { } }; -class SliceOpGradMaker : public framework::SingleGradOpDescMaker { +template +class SliceOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *bind = new framework::OpDesc(); - bind->SetInput("Input", Input("Input")); - bind->SetInput("StartsTensor", Input("StartsTensor")); - bind->SetInput("EndsTensor", Input("EndsTensor")); - bind->SetInput("StartsTensorList", Input("StartsTensorList")); - bind->SetInput("EndsTensorList", Input("EndsTensorList")); - bind->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - bind->SetOutput(framework::GradVarName("Input"), InputGrad("Input")); - bind->SetAttrMap(Attrs()); + std::unique_ptr Apply() const override { + auto *bind = new T(); + bind->SetInput("Input", this->Input("Input")); + bind->SetInput("StartsTensor", this->Input("StartsTensor")); + bind->SetInput("EndsTensor", this->Input("EndsTensor")); + bind->SetInput("StartsTensorList", this->Input("StartsTensorList")); + bind->SetInput("EndsTensorList", this->Input("EndsTensorList")); + bind->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + bind->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input")); + bind->SetAttrMap(this->Attrs()); bind->SetType("slice_grad"); - return std::unique_ptr(bind); + return std::unique_ptr(bind); } }; @@ -290,7 +291,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(SliceOpGradNoNeedBufferVarsInference, namespace ops = paddle::operators; REGISTER_OPERATOR(slice, ops::SliceOp, ops::SliceOpMaker, - ops::SliceOpGradMaker); + ops::SliceOpGradMaker, + ops::SliceOpGradMaker); REGISTER_OPERATOR(slice_grad, ops::SliceOpGrad, ops::SliceOpGradNoNeedBufferVarsInference); diff --git a/paddle/fluid/operators/smooth_l1_loss_op.cc b/paddle/fluid/operators/smooth_l1_loss_op.cc index fbfe3331188eb011159ca1e25dbdc6ea19548eed..14bf314a152b9f02b530e28d4b21a3e7b84096fe 100644 --- a/paddle/fluid/operators/smooth_l1_loss_op.cc +++ b/paddle/fluid/operators/smooth_l1_loss_op.cc @@ -154,24 +154,25 @@ class SmoothL1LossGradOp : public framework::OperatorWithKernel { } }; -class SmoothL1LossGradMaker : public framework::SingleGradOpDescMaker { +template +class SmoothL1LossGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("smooth_l1_loss_grad"); - op->SetInput("InsideWeight", Input("InsideWeight")); - op->SetInput("OutsideWeight", Input("OutsideWeight")); - op->SetInput("Diff", Output("Diff")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); + op->SetInput("InsideWeight", this->Input("InsideWeight")); + op->SetInput("OutsideWeight", this->Input("OutsideWeight")); + op->SetInput("Diff", this->Output("Diff")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); - return std::unique_ptr(op); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); + return std::unique_ptr(op); } }; @@ -180,7 +181,8 @@ class SmoothL1LossGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(smooth_l1_loss, ops::SmoothL1LossOp, ops::SmoothL1LossOpMaker, - ops::SmoothL1LossGradMaker); + ops::SmoothL1LossGradMaker, + ops::SmoothL1LossGradMaker); REGISTER_OPERATOR(smooth_l1_loss_grad, ops::SmoothL1LossGradOp); REGISTER_OP_CPU_KERNEL( smooth_l1_loss, diff --git a/paddle/fluid/operators/softmax_op.cc b/paddle/fluid/operators/softmax_op.cc index 09c08f2330725e585c8576f92a3af853867e15c8..557cdad3d09b3e21fe33eeadfb738cfd0d144427 100644 --- a/paddle/fluid/operators/softmax_op.cc +++ b/paddle/fluid/operators/softmax_op.cc @@ -199,22 +199,23 @@ class SoftmaxOpGrad : public framework::OperatorWithKernel { } }; -class SoftmaxOpGradMaker : public framework::SingleGradOpDescMaker { +template +class SoftmaxOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("softmax_grad"); - op->SetInput("Out", Output("Out")); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); + op->SetInput("Out", this->Output("Out")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - return std::unique_ptr(op); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + return std::unique_ptr(op); } }; @@ -241,7 +242,9 @@ class SoftmaxGradInplaceInferer final : public framework::InplaceOpInference { namespace ops = paddle::operators; REGISTER_OPERATOR(softmax, ops::SoftmaxOp, ops::SoftmaxOpMaker, - ops::SoftmaxOpInferVarType, ops::SoftmaxOpGradMaker, + ops::SoftmaxOpInferVarType, + ops::SoftmaxOpGradMaker, + ops::SoftmaxOpGradMaker, ops::SoftmaxInplaceInferer); REGISTER_OPERATOR(softmax_grad, ops::SoftmaxOpGrad, ops::SoftmaxGradInplaceInferer); diff --git a/paddle/fluid/operators/softmax_with_cross_entropy_op.cc b/paddle/fluid/operators/softmax_with_cross_entropy_op.cc index 727d67c2fba63a662ccd22bf95b57e4853ba1daa..ebb299ba1f3742a5d2d6d161e7163a8a73c14a1d 100644 --- a/paddle/fluid/operators/softmax_with_cross_entropy_op.cc +++ b/paddle/fluid/operators/softmax_with_cross_entropy_op.cc @@ -239,20 +239,22 @@ class SoftmaxWithCrossEntropyOpGrad : public framework::OperatorWithKernel { } }; -class SoftmaxGradMaker : public framework::SingleGradOpDescMaker { +template +class SoftmaxGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto* grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* grad_op = new T(); grad_op->SetType("softmax_with_cross_entropy_grad"); - grad_op->SetInput("Label", Input("Label")); - grad_op->SetInput("Softmax", Output("Softmax")); - grad_op->SetInput(framework::GradVarName("Loss"), OutputGrad("Loss")); - grad_op->SetOutput(framework::GradVarName("Logits"), InputGrad("Logits")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("Label", this->Input("Label")); + grad_op->SetInput("Softmax", this->Output("Softmax")); + grad_op->SetInput(framework::GradVarName("Loss"), this->OutputGrad("Loss")); + grad_op->SetOutput(framework::GradVarName("Logits"), + this->InputGrad("Logits")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -268,7 +270,9 @@ DECLARE_INPLACE_OP_INFERER(SoftmaxWithCrossEntropyGradInplaceInference, namespace ops = paddle::operators; REGISTER_OPERATOR(softmax_with_cross_entropy, ops::SoftmaxWithCrossEntropyOp, - ops::SoftmaxWithCrossEntropyOpMaker, ops::SoftmaxGradMaker, + ops::SoftmaxWithCrossEntropyOpMaker, + ops::SoftmaxGradMaker, + ops::SoftmaxGradMaker, ops::SoftmaxWithCrossEntropyInplaceInference); REGISTER_OPERATOR(softmax_with_cross_entropy_grad, ops::SoftmaxWithCrossEntropyOpGrad, diff --git a/paddle/fluid/operators/space_to_depth_op.cc b/paddle/fluid/operators/space_to_depth_op.cc index e2c2998095eb2d976377e284fbe84eee03feb095..133be773ac76e376b3bcb57e0b3a9061091cc16b 100644 --- a/paddle/fluid/operators/space_to_depth_op.cc +++ b/paddle/fluid/operators/space_to_depth_op.cc @@ -133,22 +133,23 @@ class SpaceToDepthOpMaker : public framework::OpProtoAndCheckerMaker { DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(SpaceToDepthGradOpNoBuffer, "X"); -class SpaceToDepthGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class SpaceToDepthGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("space_to_depth_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput("X", Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput("X", this->Input("X")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -178,7 +179,8 @@ class SpaceToDepthGradOp : public framework::OperatorWithKernel { namespace ops = paddle::operators; REGISTER_OPERATOR(space_to_depth, ops::SpaceToDepthOp, ops::SpaceToDepthOpMaker, - ops::SpaceToDepthGradOpDescMaker); + ops::SpaceToDepthGradOpMaker, + ops::SpaceToDepthGradOpMaker); REGISTER_OPERATOR(space_to_depth_grad, ops::SpaceToDepthGradOp, ops::SpaceToDepthGradOpNoBuffer); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/spectral_norm_op.cc b/paddle/fluid/operators/spectral_norm_op.cc index 71049c58e1670d787b608616fcd4d51aabb54a71..2cdcaeaf09db55b1ca403e77991375d796707dee 100644 --- a/paddle/fluid/operators/spectral_norm_op.cc +++ b/paddle/fluid/operators/spectral_norm_op.cc @@ -168,23 +168,24 @@ class SpectralNormOpMaker : public framework::OpProtoAndCheckerMaker { } }; -class SpectralNormGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class SpectralNormGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("spectral_norm_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput("Weight", Input("Weight")); - op->SetInput("U", Input("U")); - op->SetInput("V", Input("V")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput("Weight", this->Input("Weight")); + op->SetInput("U", this->Input("U")); + op->SetInput("V", this->Input("V")); - op->SetOutput(framework::GradVarName("Weight"), InputGrad("Weight")); + op->SetOutput(framework::GradVarName("Weight"), this->InputGrad("Weight")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); return op; } @@ -219,7 +220,8 @@ class SpectralNormOpGrad : public framework::OperatorWithKernel { namespace ops = paddle::operators; REGISTER_OPERATOR(spectral_norm, ops::SpectralNormOp, ops::SpectralNormOpMaker, - ops::SpectralNormGradOpDescMaker); + ops::SpectralNormGradOpMaker, + ops::SpectralNormGradOpMaker); REGISTER_OPERATOR(spectral_norm_grad, ops::SpectralNormOpGrad); REGISTER_OP_CPU_KERNEL( spectral_norm, diff --git a/paddle/fluid/operators/split_lod_tensor_op.cc b/paddle/fluid/operators/split_lod_tensor_op.cc index 870adfbaa79cc7b19869bb778c7ff4ef57b487ca..fedd8543ae803a1b99167ab835ca55865b096339 100644 --- a/paddle/fluid/operators/split_lod_tensor_op.cc +++ b/paddle/fluid/operators/split_lod_tensor_op.cc @@ -180,21 +180,22 @@ class SplitLoDTensorInferShape : public framework::InferShapeBase { } }; -class SplitLoDTensorArrayGradMaker : public framework::SingleGradOpDescMaker { +template +class SplitLoDTensorArrayGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("merge_lod_tensor"); - grad_op->SetInput("InTrue", OutputGrad("OutTrue")); - grad_op->SetInput("InFalse", OutputGrad("OutFalse")); - grad_op->SetInput("Mask", Input("Mask")); - grad_op->SetInput("X", Input("X")); - grad_op->SetOutput("Out", InputGrad("X")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("InTrue", this->OutputGrad("OutTrue")); + grad_op->SetInput("InFalse", this->OutputGrad("OutFalse")); + grad_op->SetInput("Mask", this->Input("Mask")); + grad_op->SetInput("X", this->Input("X")); + grad_op->SetOutput("Out", this->InputGrad("X")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -202,7 +203,8 @@ class SplitLoDTensorArrayGradMaker : public framework::SingleGradOpDescMaker { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(split_lod_tensor, ops::SplitLoDTensorOp, - ops::SplitLoDTensorOpProtoMaker, - ops::SplitLoDTensorInferShape, - ops::SplitLoDTensorArrayGradMaker); +REGISTER_OPERATOR( + split_lod_tensor, ops::SplitLoDTensorOp, ops::SplitLoDTensorOpProtoMaker, + ops::SplitLoDTensorInferShape, + ops::SplitLoDTensorArrayGradMaker, + ops::SplitLoDTensorArrayGradMaker); diff --git a/paddle/fluid/operators/split_op.cc b/paddle/fluid/operators/split_op.cc index 5277440f5b622cca074f333071a601d82cc4a58d..997d3fe4e3ca0a19b88220a8bc74284012466281 100644 --- a/paddle/fluid/operators/split_op.cc +++ b/paddle/fluid/operators/split_op.cc @@ -140,8 +140,11 @@ Example: } // namespace paddle namespace ops = paddle::operators; + +REGISTER_OPERATOR(split, ops::SplitOp, ops::SplitOpMaker, + ops::SplitGradMaker, + ops::SplitGradMaker); namespace plat = paddle::platform; -REGISTER_OPERATOR(split, ops::SplitOp, ops::SplitOpMaker, ops::SplitGradMaker); REGISTER_OP_CPU_KERNEL( split, ops::SplitOpKernel, ops::SplitOpKernel, diff --git a/paddle/fluid/operators/split_op.h b/paddle/fluid/operators/split_op.h index 77d630235f7c9b129da3ac75f85a24f07be1091e..552b27df1b61a92a6825fc4ca6a2161616b46729 100644 --- a/paddle/fluid/operators/split_op.h +++ b/paddle/fluid/operators/split_op.h @@ -153,19 +153,20 @@ class SplitOpKernel : public framework::OpKernel { } }; -class SplitGradMaker : public framework::SingleGradOpDescMaker { +template +class SplitGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto op = new T(); op->SetType("concat"); - op->SetInput("X", OutputGrad("Out")); - op->SetInput("AxisTensor", Input("AxisTensor")); - op->SetOutput("Out", InputGrad("X")); - op->SetAttrMap(Attrs()); - return std::unique_ptr(op); + op->SetInput("X", this->OutputGrad("Out")); + op->SetInput("AxisTensor", this->Input("AxisTensor")); + op->SetOutput("Out", this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); + return std::unique_ptr(op); } }; diff --git a/paddle/fluid/operators/split_selected_rows_op.cc b/paddle/fluid/operators/split_selected_rows_op.cc index 88dfebc0cff0d0f7752c372780f1d952667ec630..b0217d93e9294f6cab264959e35f9c9c9896c2dc 100644 --- a/paddle/fluid/operators/split_selected_rows_op.cc +++ b/paddle/fluid/operators/split_selected_rows_op.cc @@ -69,18 +69,19 @@ class SplitSelectedRowsOpInferVarType : public framework::VarTypeInference { } }; -class SplitSelectedRowsGradMaker : public framework::SingleGradOpDescMaker { +template +class SplitSelectedRowsGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("sum"); - grad_op->SetInput("X", OutputGrad("Out")); - grad_op->SetOutput("Out", InputGrad("X")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("X", this->OutputGrad("Out")); + grad_op->SetOutput("Out", this->InputGrad("X")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -90,7 +91,8 @@ class SplitSelectedRowsGradMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(split_selected_rows, ops::SplitSelectedRowsOp, ops::SplitSelectedRowsOpMaker, - ops::SplitSelectedRowsGradMaker, + ops::SplitSelectedRowsGradMaker, + ops::SplitSelectedRowsGradMaker, ops::SplitSelectedRowsOpInferVarType); REGISTER_OP_CPU_KERNEL( split_selected_rows, diff --git a/paddle/fluid/operators/spp_op.cc b/paddle/fluid/operators/spp_op.cc index a2a96b72f09df86790ad1f90ead9189ff9bd581c..e9ed900ea0f7b084c902909f0c61e00a84e0cba4 100644 --- a/paddle/fluid/operators/spp_op.cc +++ b/paddle/fluid/operators/spp_op.cc @@ -91,8 +91,10 @@ class SppOpGrad : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(spp, ops::SppOp, ops::SppOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + spp, ops::SppOp, ops::SppOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(spp_grad, ops::SppOpGrad); REGISTER_OP_CPU_KERNEL( spp, ops::SppKernel, diff --git a/paddle/fluid/operators/squared_l2_distance_op.cc b/paddle/fluid/operators/squared_l2_distance_op.cc index 6c0b195decc36d9c751adeef6c78168495577843..47683fabd33282bd4255c89136c58fb7df850d27 100644 --- a/paddle/fluid/operators/squared_l2_distance_op.cc +++ b/paddle/fluid/operators/squared_l2_distance_op.cc @@ -74,26 +74,26 @@ class SquaredL2DistanceOp : public framework::OperatorWithKernel { DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(SquaredL2DistanceGradOpNoBuffer, "X", "Y"); -class SquaredL2DistanceGradOpDescMaker - : public framework::SingleGradOpDescMaker { +template +class SquaredL2DistanceGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("squared_l2_distance_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput("sub_result", Output("sub_result")); - op->SetInput("X", Input("X")); - op->SetInput("Y", Input("Y")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput("sub_result", this->Output("sub_result")); + op->SetInput("X", this->Input("X")); + op->SetInput("Y", this->Input("Y")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetOutput(framework::GradVarName("Y"), InputGrad("Y")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); return op; } @@ -164,9 +164,11 @@ class SquaredL2DistanceGradOp : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(squared_l2_distance, ops::SquaredL2DistanceOp, - ops::SquaredL2DistanceOpMaker, - ops::SquaredL2DistanceGradOpDescMaker); +REGISTER_OPERATOR( + squared_l2_distance, ops::SquaredL2DistanceOp, + ops::SquaredL2DistanceOpMaker, + ops::SquaredL2DistanceGradOpMaker, + ops::SquaredL2DistanceGradOpMaker); REGISTER_OPERATOR(squared_l2_distance_grad, ops::SquaredL2DistanceGradOp, ops::SquaredL2DistanceGradOpNoBuffer); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/squared_l2_norm_op.cc b/paddle/fluid/operators/squared_l2_norm_op.cc index 9d2deb678ecf714421f507af88e7eabade7ecb68..81a8a7beaed78a392e8cbde4243cecaab8688c0d 100644 --- a/paddle/fluid/operators/squared_l2_norm_op.cc +++ b/paddle/fluid/operators/squared_l2_norm_op.cc @@ -33,22 +33,23 @@ class SquaredL2NormOp : public framework::OperatorWithKernel { } }; -class SquaredL2NormGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class SquaredL2NormGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("squared_l2_norm_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput("X", Input("X")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput("X", this->Input("X")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -89,7 +90,9 @@ $$Out = \sum_{i} X_{i}^2$$ namespace ops = paddle::operators; REGISTER_OPERATOR(squared_l2_norm, ops::SquaredL2NormOp, - ops::SquaredL2NormOpMaker, ops::SquaredL2NormGradOpDescMaker); + ops::SquaredL2NormOpMaker, + ops::SquaredL2NormGradOpMaker, + ops::SquaredL2NormGradOpMaker); REGISTER_OPERATOR(squared_l2_norm_grad, ops::SquaredL2NormGradOp); REGISTER_OP_CPU_KERNEL( squared_l2_norm, diff --git a/paddle/fluid/operators/squeeze_op.cc b/paddle/fluid/operators/squeeze_op.cc index a7e10457fd7a96d20005014a14e9533830b6031c..76817f302c60306cc3d000a72ca778a07e49c038 100644 --- a/paddle/fluid/operators/squeeze_op.cc +++ b/paddle/fluid/operators/squeeze_op.cc @@ -254,18 +254,19 @@ class Squeeze2OpMaker : public SqueezeOpMaker { } }; -class Squeeze2GradOpMaker : public framework::SingleGradOpDescMaker { +template +class Squeeze2GradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("squeeze2_grad"); - grad_op->SetInput("XShape", Output("XShape")); - grad_op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - grad_op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("XShape", this->Output("XShape")); + grad_op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + grad_op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -278,12 +279,16 @@ DECLARE_INPLACE_OP_INFERER(SequeezeGradInplaceInferer, } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(squeeze, ops::SqueezeOp, ops::SqueezeOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + squeeze, ops::SqueezeOp, ops::SqueezeOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(squeeze_grad, ops::SqueezeGradOp); REGISTER_OPERATOR(squeeze2, ops::Squeeze2Op, ops::Squeeze2OpMaker, - ops::Squeeze2GradOpMaker, ops::SequeezeInplaceInferer); + ops::Squeeze2GradOpMaker, + ops::Squeeze2GradOpMaker, + ops::SequeezeInplaceInferer); REGISTER_OPERATOR(squeeze2_grad, ops::Squeeze2GradOp, ops::SequeezeGradInplaceInferer); diff --git a/paddle/fluid/operators/stack_op.cc b/paddle/fluid/operators/stack_op.cc index 9345b495415d203728238c19621a20f446c40bf5..b2e46cccfc4b272afea37cf869104d0cacb0a152 100644 --- a/paddle/fluid/operators/stack_op.cc +++ b/paddle/fluid/operators/stack_op.cc @@ -17,7 +17,8 @@ namespace plat = paddle::platform; namespace ops = paddle::operators; REGISTER_OPERATOR(stack, ops::StackOp, ops::StackOpMaker, - ops::StackGradOpDescMaker); + ops::StackGradOpMaker, + ops::StackGradOpMaker); REGISTER_OPERATOR(stack_grad, ops::StackOpGrad); REGISTER_OP_CPU_KERNEL(stack, ops::StackKernel, diff --git a/paddle/fluid/operators/stack_op.h b/paddle/fluid/operators/stack_op.h index 9ebf166d7034cd55d9f920128580d06e53cfac18..9cb391c048a06e0d958c3a5137a7e3de594dab3b 100644 --- a/paddle/fluid/operators/stack_op.h +++ b/paddle/fluid/operators/stack_op.h @@ -205,17 +205,18 @@ class StackOpGrad : public framework::OperatorWithKernel { } }; -class StackGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class StackGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("stack_grad"); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X", false)); - op->SetAttrMap(Attrs()); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X", false)); + op->SetAttrMap(this->Attrs()); return op; } }; diff --git a/paddle/fluid/operators/strided_slice_op.cc b/paddle/fluid/operators/strided_slice_op.cc index 5cd7a78636379f19c6be686198f249f2370ceb40..c64e8beb2540114cf005933953f2d6eae3dcffeb 100644 --- a/paddle/fluid/operators/strided_slice_op.cc +++ b/paddle/fluid/operators/strided_slice_op.cc @@ -251,25 +251,26 @@ class StridedSliceOpGrad : public framework::OperatorWithKernel { } }; -class StridedSliceOpGradMaker : public framework::SingleGradOpDescMaker { +template +class StridedSliceOpGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - auto *bind = new framework::OpDesc(); - bind->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - bind->SetInput("Input", Input("Input")); - bind->SetInput("StartsTensor", Input("StartsTensor")); - bind->SetInput("EndsTensor", Input("EndsTensor")); - bind->SetInput("StridesTensor", Input("StridesTensor")); - bind->SetInput("StartsTensorList", Input("StartsTensorList")); - bind->SetInput("EndsTensorList", Input("EndsTensorList")); - bind->SetInput("StridesTensorList", Input("StridesTensorList")); - bind->SetOutput(framework::GradVarName("Input"), InputGrad("Input")); - bind->SetAttrMap(Attrs()); + std::unique_ptr Apply() const override { + auto *bind = new T(); + bind->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + bind->SetInput("Input", this->Input("Input")); + bind->SetInput("StartsTensor", this->Input("StartsTensor")); + bind->SetInput("EndsTensor", this->Input("EndsTensor")); + bind->SetInput("StridesTensor", this->Input("StridesTensor")); + bind->SetInput("StartsTensorList", this->Input("StartsTensorList")); + bind->SetInput("EndsTensorList", this->Input("EndsTensorList")); + bind->SetInput("StridesTensorList", this->Input("StridesTensorList")); + bind->SetOutput(framework::GradVarName("Input"), this->InputGrad("Input")); + bind->SetAttrMap(this->Attrs()); bind->SetType("strided_slice_grad"); - return std::unique_ptr(bind); + return std::unique_ptr(bind); } }; @@ -281,7 +282,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE( namespace ops = paddle::operators; REGISTER_OPERATOR(strided_slice, ops::StridedSliceOp, ops::StridedSliceOpMaker, - ops::StridedSliceOpGradMaker); + ops::StridedSliceOpGradMaker, + ops::StridedSliceOpGradMaker); REGISTER_OPERATOR(strided_slice_grad, ops::StridedSliceOpGrad, ops::StridedSliceOpGradNoNeedBufferVarsInference); diff --git a/paddle/fluid/operators/sum_op.cc b/paddle/fluid/operators/sum_op.cc index 27b66250d7397fba496683dc11221fca614788c1..33eef7b075cbe4e48a1bca5e8c3905cba59e5d1d 100644 --- a/paddle/fluid/operators/sum_op.cc +++ b/paddle/fluid/operators/sum_op.cc @@ -236,7 +236,7 @@ class SumOpVarTypeInference : public framework::VarTypeInference { } }; -class SumGradMaker : public framework::GradOpDescMakerBase { +class SumGradDescMaker : public framework::GradOpDescMakerBase { public: using framework::GradOpDescMakerBase::GradOpDescMakerBase; @@ -254,6 +254,30 @@ class SumGradMaker : public framework::GradOpDescMakerBase { grad_op->SetAttr("scale", 1.0f); return std::unique_ptr(grad_op); }); + + return grad_ops; + } +}; + +class SumGradOpBaseMaker : public imperative::GradOpBaseMakerBase { + public: + using imperative::GradOpBaseMakerBase::GradOpBaseMakerBase; + + std::vector> operator()() const override { + auto x_grads = InputGrad("X", false); + std::vector> grad_ops; + grad_ops.reserve(x_grads.size()); + auto og = OutputGrad("Out"); + std::transform(x_grads.begin(), x_grads.end(), std::back_inserter(grad_ops), + [&og](const std::shared_ptr& x_grad) { + auto* grad_op = new imperative::OpBase(); + grad_op->SetType("scale"); + grad_op->SetInput("X", og); + grad_op->SetOutput("Out", {x_grad}); + grad_op->SetAttr("scale", 1.0f); + return std::unique_ptr(grad_op); + }); + return grad_ops; } }; @@ -265,8 +289,9 @@ DECLARE_INPLACE_OP_INFERER(SumInplace, {"X", "Out"}); namespace ops = paddle::operators; -REGISTER_OPERATOR(sum, ops::SumOp, ops::SumOpMaker, ops::SumGradMaker, - ops::SumOpVarTypeInference, ops::SumInplace); +REGISTER_OPERATOR(sum, ops::SumOp, ops::SumOpMaker, ops::SumGradDescMaker, + ops::SumGradOpBaseMaker, ops::SumOpVarTypeInference, + ops::SumInplace); REGISTER_OP_CPU_KERNEL( sum, ops::SumKernel, diff --git a/paddle/fluid/operators/sync_batch_norm_op.cc b/paddle/fluid/operators/sync_batch_norm_op.cc index d6cf27fd779eeddc94c1839e46892a99f61bd1bf..a134541dd78066a73d813a6bd19b9ef65c0a48e7 100644 --- a/paddle/fluid/operators/sync_batch_norm_op.cc +++ b/paddle/fluid/operators/sync_batch_norm_op.cc @@ -14,7 +14,47 @@ limitations under the License. */ #include "paddle/fluid/operators/batch_norm_op.h" +namespace paddle { +namespace operators { +template +class BatchNormGradMaker : public framework::SingleGradOpMaker { + public: + using framework::SingleGradOpMaker::SingleGradOpMaker; + + protected: + std::unique_ptr Apply() const override { + auto *op = new T(); + op->SetType(this->ForwardOpType() + "_grad"); + op->SetInput("X", this->Input("X")); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + + op->SetInput("Scale", this->Input("Scale")); + op->SetInput("Bias", this->Input("Bias")); + op->SetInput("SavedMean", this->Output("SavedMean")); + op->SetInput("SavedVariance", this->Output("SavedVariance")); + + // used when setting use_global_stats True during training + if (boost::get(this->GetAttr("use_global_stats"))) { + op->SetInput("Mean", this->Output("MeanOut")); + op->SetInput("Variance", this->Output("VarianceOut")); + } + + op->SetAttrMap(this->Attrs()); + + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetOutput(framework::GradVarName("Scale"), this->InputGrad("Scale")); + op->SetOutput(framework::GradVarName("Bias"), this->InputGrad("Bias")); + + return std::unique_ptr(op); + } +}; + +} // namespace operators +} // namespace paddle + namespace ops = paddle::operators; REGISTER_OPERATOR(sync_batch_norm, ops::BatchNormOp, ops::BatchNormOpMaker, - ops::BatchNormOpInferVarType, ops::BatchNormGradMaker); + ops::BatchNormOpInferVarType, + ops::BatchNormGradMaker, + ops::BatchNormGradMaker); REGISTER_OPERATOR(sync_batch_norm_grad, ops::BatchNormGradOp); diff --git a/paddle/fluid/operators/teacher_student_sigmoid_loss_op.cc b/paddle/fluid/operators/teacher_student_sigmoid_loss_op.cc index 7823b9d8501782d84e23916ef54892338f617ca3..e237a9a6503d0a479e1ae30621fd81202b8edaf4 100644 --- a/paddle/fluid/operators/teacher_student_sigmoid_loss_op.cc +++ b/paddle/fluid/operators/teacher_student_sigmoid_loss_op.cc @@ -61,24 +61,25 @@ class TeacherStudentSigmoidLossOp : public framework::OperatorWithKernel { } }; -class TeacherStudentSigmoidLossGradOpDescMaker - : public framework::SingleGradOpDescMaker { +template +class TeacherStudentSigmoidLossGradOpMaker + : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("teacher_student_sigmoid_loss_grad"); - op->SetInput("X", Input("X")); - op->SetInput("Label", Input("Label")); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); + op->SetInput("X", this->Input("X")); + op->SetInput("Label", this->Input("Label")); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -177,10 +178,11 @@ we add another label(z') to original. } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(teacher_student_sigmoid_loss, - ops::TeacherStudentSigmoidLossOp, - ops::TeacherStudentSigmoidLossOpMaker, - ops::TeacherStudentSigmoidLossGradOpDescMaker); +REGISTER_OPERATOR( + teacher_student_sigmoid_loss, ops::TeacherStudentSigmoidLossOp, + ops::TeacherStudentSigmoidLossOpMaker, + ops::TeacherStudentSigmoidLossGradOpMaker, + ops::TeacherStudentSigmoidLossGradOpMaker); REGISTER_OPERATOR(teacher_student_sigmoid_loss_grad, ops::TeacherStudentSigmoidLossGradientOp); diff --git a/paddle/fluid/operators/temporal_shift_op.cc b/paddle/fluid/operators/temporal_shift_op.cc index 6663d3f5571af0bf2ed020fab7290a1abe7c1afc..7270c5fc5be1cf90ad0d84cdf7fa5870e8e57d3d 100644 --- a/paddle/fluid/operators/temporal_shift_op.cc +++ b/paddle/fluid/operators/temporal_shift_op.cc @@ -145,17 +145,18 @@ class TemporalShiftOpGrad : public framework::OperatorWithKernel { } }; -class TemporalShiftGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class TemporalShiftGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("temporal_shift_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -165,7 +166,9 @@ class TemporalShiftGradOpDescMaker : public framework::SingleGradOpDescMaker { namespace ops = paddle::operators; REGISTER_OPERATOR(temporal_shift, ops::TemporalShiftOp, - ops::TemporalShiftOpMaker, ops::TemporalShiftGradOpDescMaker); + ops::TemporalShiftOpMaker, + ops::TemporalShiftGradOpMaker, + ops::TemporalShiftGradOpMaker); REGISTER_OPERATOR(temporal_shift_grad, ops::TemporalShiftOpGrad); REGISTER_OP_CPU_KERNEL(temporal_shift, ops::TemporalShiftKernel, ops::TemporalShiftKernel); diff --git a/paddle/fluid/operators/tensor_array_to_tensor_op.cc b/paddle/fluid/operators/tensor_array_to_tensor_op.cc index 82741077d9cf09bd85b295d8fac77acd28b4e057..e6f78f52d682449051d31b82f1e9f50ce2680776 100644 --- a/paddle/fluid/operators/tensor_array_to_tensor_op.cc +++ b/paddle/fluid/operators/tensor_array_to_tensor_op.cc @@ -278,10 +278,11 @@ class LoDTensorArray2TensorGradOp : public framework::OperatorBase { USE_OP(concat); namespace ops = paddle::operators; -REGISTER_OPERATOR(tensor_array_to_tensor, ops::LoDTensorArray2TensorOp, - ops::LoDTensorArray2TensorOpMaker, - ops::LoDTensorArray2TensorOpInferShape, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + tensor_array_to_tensor, ops::LoDTensorArray2TensorOp, + ops::LoDTensorArray2TensorOpMaker, ops::LoDTensorArray2TensorOpInferShape, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(tensor_array_to_tensor_grad, ops::LoDTensorArray2TensorGradOp, ops::LoDTensorArray2TensorGradInferShape, ops::LoDTensorArray2TensorGradInferVarType); diff --git a/paddle/fluid/operators/top_k_op.cc b/paddle/fluid/operators/top_k_op.cc index fdf5148eb8790bb3a9fd89ab3ec107569caf7c9d..436bb5d7221c6bdfe11d5c1e1ca9c8d411a8bc50 100644 --- a/paddle/fluid/operators/top_k_op.cc +++ b/paddle/fluid/operators/top_k_op.cc @@ -88,8 +88,10 @@ For matrices, this operator computes the top k entries in each row. )DOC"); } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(top_k, ops::TopkOp, ops::TopkOpMaker, - paddle::framework::EmptyGradOpMaker); +REGISTER_OPERATOR( + top_k, ops::TopkOp, ops::TopkOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker); REGISTER_OP_CPU_KERNEL(top_k, ops::TopkKernel, ops::TopkKernel); diff --git a/paddle/fluid/operators/transpose_op.cc b/paddle/fluid/operators/transpose_op.cc index eab6d437d4705d95428ef7fa8bb47dcb84391b08..de22faa2d2d598b708d2e82bb578d13f4f41faa1 100644 --- a/paddle/fluid/operators/transpose_op.cc +++ b/paddle/fluid/operators/transpose_op.cc @@ -225,18 +225,19 @@ class Transpose2OpMaker : public TransposeOpMaker { } }; -class Transpose2GradMaker : public framework::SingleGradOpDescMaker { +template +class Transpose2GradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("transpose2_grad"); - grad_op->SetInput("XShape", Output("XShape")); - grad_op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - grad_op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("XShape", this->Output("XShape")); + grad_op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + grad_op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -280,8 +281,10 @@ class Transpose2OpGrad : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(transpose, ops::TransposeOp, ops::TransposeOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + transpose, ops::TransposeOp, ops::TransposeOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(transpose_grad, ops::TransposeOpGrad); REGISTER_OP_CPU_KERNEL( @@ -293,7 +296,8 @@ REGISTER_OP_CPU_KERNEL( ops::TransposeGradKernel); REGISTER_OPERATOR(transpose2, ops::Transpose2Op, ops::Transpose2OpMaker, - ops::Transpose2GradMaker); + ops::Transpose2GradMaker, + ops::Transpose2GradMaker); REGISTER_OPERATOR(transpose2_grad, ops::Transpose2OpGrad); REGISTER_OP_CPU_KERNEL( diff --git a/paddle/fluid/operators/tree_conv_op.cc b/paddle/fluid/operators/tree_conv_op.cc index 0c72275c5bbacceab6391935e286614ac8f0adca..0ed0b558fdce1bdba67a767f692b5ed566724af8 100644 --- a/paddle/fluid/operators/tree_conv_op.cc +++ b/paddle/fluid/operators/tree_conv_op.cc @@ -110,26 +110,27 @@ class TreeConvOp : public framework::OperatorWithKernel { } }; -class TreeConvGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class TreeConvGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("tree_conv_grad"); - op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - op->SetInput("Filter", Input("Filter")); - op->SetInput("EdgeSet", Input("EdgeSet")); - op->SetInput("NodesVector", Input("NodesVector")); + op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + op->SetInput("Filter", this->Input("Filter")); + op->SetInput("EdgeSet", this->Input("EdgeSet")); + op->SetInput("NodesVector", this->Input("NodesVector")); op->SetOutput(framework::GradVarName("NodesVector"), - InputGrad("NodesVector")); - op->SetOutput(framework::GradVarName("Filter"), InputGrad("Filter")); + this->InputGrad("NodesVector")); + op->SetOutput(framework::GradVarName("Filter"), this->InputGrad("Filter")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -164,7 +165,8 @@ class TreeConvGradOp : public framework::OperatorWithKernel { namespace ops = paddle::operators; REGISTER_OPERATOR(tree_conv, ops::TreeConvOp, ops::TreeConvOpMaker, - ops::TreeConvGradOpDescMaker); + ops::TreeConvGradOpMaker, + ops::TreeConvGradOpMaker); REGISTER_OPERATOR(tree_conv_grad, ops::TreeConvGradOp); diff --git a/paddle/fluid/operators/unfold_op.cc b/paddle/fluid/operators/unfold_op.cc index 99907e066b27a5f0ab586d0960d9c9c03d306c2f..6f0f523001905d53568bcd77c489003ebb75bf0c 100644 --- a/paddle/fluid/operators/unfold_op.cc +++ b/paddle/fluid/operators/unfold_op.cc @@ -148,18 +148,19 @@ class UnfoldGradOp : public framework::OperatorWithKernel { } }; -class UnfoldGradDescMaker : public framework::SingleGradOpDescMaker { +template +class UnfoldGradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("unfold_grad"); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - op->SetInput("X", Input("X")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + op->SetInput("X", this->Input("X")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -172,7 +173,8 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERENCE(UnfoldGradOpNoNeedBufferVarsInference, namespace ops = paddle::operators; REGISTER_OPERATOR(unfold, ops::UnfoldOp, ops::UnfoldOpMaker, - ops::UnfoldGradDescMaker); + ops::UnfoldGradMaker, + ops::UnfoldGradMaker); REGISTER_OPERATOR(unfold_grad, ops::UnfoldGradOp, ops::UnfoldGradOpNoNeedBufferVarsInference); diff --git a/paddle/fluid/operators/uniform_random_batch_size_like_op.cc b/paddle/fluid/operators/uniform_random_batch_size_like_op.cc index 598c9042cfb9f308e12e270172fb0453b6b7e634..f90bb4be03474e48e1ac6a4ea00b5a7732ed69be 100644 --- a/paddle/fluid/operators/uniform_random_batch_size_like_op.cc +++ b/paddle/fluid/operators/uniform_random_batch_size_like_op.cc @@ -72,9 +72,11 @@ with random values sampled from a uniform distribution. } // namespace operators } // namespace paddle -REGISTER_OPERATOR(uniform_random_batch_size_like, - paddle::operators::UniformRandomBatchSizeLikeOp, - paddle::operators::UniformRandomBatchSizeLikeOpMaker, - paddle::framework::EmptyGradOpMaker, - paddle::operators::BatchSizeLikeNoNeedBufferVarsInference); +REGISTER_OPERATOR( + uniform_random_batch_size_like, + paddle::operators::UniformRandomBatchSizeLikeOp, + paddle::operators::UniformRandomBatchSizeLikeOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::operators::BatchSizeLikeNoNeedBufferVarsInference); // Kernels are registered in uniform_random_op.cc and uniform_random_op.cu diff --git a/paddle/fluid/operators/uniform_random_op.cc b/paddle/fluid/operators/uniform_random_op.cc index e81d8a22feeb3216bf0ee74f2f0edfd3f3f31980..566fe662156dcef3ccd8c48dad6c7c85c1760bb6 100644 --- a/paddle/fluid/operators/uniform_random_op.cc +++ b/paddle/fluid/operators/uniform_random_op.cc @@ -235,10 +235,12 @@ class UniformRandomOpVarTypeInference : public framework::VarTypeInference { } // namespace operators } // namespace paddle -REGISTER_OPERATOR(uniform_random, paddle::operators::UniformRandomOp, - paddle::operators::UniformRandomOpMaker, - paddle::framework::EmptyGradOpMaker, - paddle::operators::UniformRandomOpVarTypeInference); +REGISTER_OPERATOR( + uniform_random, paddle::operators::UniformRandomOp, + paddle::operators::UniformRandomOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::framework::EmptyGradOpMaker, + paddle::operators::UniformRandomOpVarTypeInference); REGISTER_OP_CPU_KERNEL(uniform_random, paddle::operators::CPUUniformRandomKernel, diff --git a/paddle/fluid/operators/unpool_op.cc b/paddle/fluid/operators/unpool_op.cc index 0693df843eb8411f0ed39adbffb0f36e7021037f..fae63c90bb2df5b958c2339fa642a3222007fd93 100644 --- a/paddle/fluid/operators/unpool_op.cc +++ b/paddle/fluid/operators/unpool_op.cc @@ -136,8 +136,11 @@ class UnpoolOpGrad : public framework::OperatorWithKernel { } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(unpool, ops::UnpoolOp, ops::Unpool2dOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + unpool, ops::UnpoolOp, ops::Unpool2dOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); + REGISTER_OPERATOR(unpool_grad, ops::UnpoolOpGrad); REGISTER_OP_CPU_KERNEL( unpool, ops::UnpoolKernel, diff --git a/paddle/fluid/operators/unsqueeze_op.cc b/paddle/fluid/operators/unsqueeze_op.cc index 22f2a0fc3550587e95c8a3c7b47e2a3474ea9bea..b0a458cbb87121ae159de904ee3bb86e831280f7 100644 --- a/paddle/fluid/operators/unsqueeze_op.cc +++ b/paddle/fluid/operators/unsqueeze_op.cc @@ -220,18 +220,19 @@ class Unsqueeze2OpMaker : public UnsqueezeOpMaker { } }; -class Unsqueeze2GradOpMaker : public framework::SingleGradOpDescMaker { +template +class Unsqueeze2GradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto *grad_op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto *grad_op = new T(); grad_op->SetType("unsqueeze2_grad"); - grad_op->SetInput("XShape", Output("XShape")); - grad_op->SetInput(framework::GradVarName("Out"), OutputGrad("Out")); - grad_op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - grad_op->SetAttrMap(Attrs()); - return std::unique_ptr(grad_op); + grad_op->SetInput("XShape", this->Output("XShape")); + grad_op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); + grad_op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + grad_op->SetAttrMap(this->Attrs()); + return std::unique_ptr(grad_op); } }; @@ -266,12 +267,16 @@ DECLARE_INPLACE_OP_INFERER(UnsqueezeGradInplaceInferer, } // namespace paddle namespace ops = paddle::operators; -REGISTER_OPERATOR(unsqueeze, ops::UnsqueezeOp, ops::UnsqueezeOpMaker, - paddle::framework::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + unsqueeze, ops::UnsqueezeOp, ops::UnsqueezeOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(unsqueeze_grad, ops::UnsqueezeGradOp); REGISTER_OPERATOR(unsqueeze2, ops::Unsqueeze2Op, ops::Unsqueeze2OpMaker, - ops::Unsqueeze2GradOpMaker, ops::UnsqueezeInplaceInferer); + ops::Unsqueeze2GradOpMaker, + ops::Unsqueeze2GradOpMaker, + ops::UnsqueezeInplaceInferer); REGISTER_OPERATOR(unsqueeze2_grad, ops::Unsqueeze2GradOp, ops::UnsqueezeGradInplaceInferer); diff --git a/paddle/fluid/operators/unstack_op.cc b/paddle/fluid/operators/unstack_op.cc index 204aa1fa6709485b7f277270cd4cc8e32b757515..737f9d929e9f92c41e8aa442e9adebc9f71a1b69 100644 --- a/paddle/fluid/operators/unstack_op.cc +++ b/paddle/fluid/operators/unstack_op.cc @@ -69,17 +69,18 @@ class UnStackOpMaker : public framework::OpProtoAndCheckerMaker { } }; -class UnStackGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class UnStackGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("unstack_grad"); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - op->SetAttrMap(Attrs()); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -123,7 +124,8 @@ namespace plat = paddle::platform; namespace ops = paddle::operators; REGISTER_OPERATOR(unstack, ops::UnStackOp, ops::UnStackOpMaker, - ops::UnStackGradOpDescMaker); + ops::UnStackGradOpMaker, + ops::UnStackGradOpMaker); REGISTER_OPERATOR(unstack_grad, ops::UnStackGradOp); diff --git a/paddle/fluid/operators/var_conv_2d_op.cc b/paddle/fluid/operators/var_conv_2d_op.cc index 232075203a0705ba5c68c80bae7cbf4613cbb970..32967f8af50ae319aec1a363092e57e7c875aa50 100644 --- a/paddle/fluid/operators/var_conv_2d_op.cc +++ b/paddle/fluid/operators/var_conv_2d_op.cc @@ -416,8 +416,10 @@ class CPUVarConv2dOPGradKernel : public framework::OpKernel { namespace ops = paddle::operators; namespace plt = paddle::platform; namespace frm = paddle::framework; -REGISTER_OPERATOR(var_conv_2d, ops::VarConv2dOP, ops::VarConv2dOpMaker, - frm::DefaultGradOpDescMaker); +REGISTER_OPERATOR( + var_conv_2d, ops::VarConv2dOP, ops::VarConv2dOpMaker, + paddle::framework::DefaultGradOpMaker, + paddle::framework::DefaultGradOpMaker); REGISTER_OPERATOR(var_conv_2d_grad, ops::VarConv2dOpGrad); REGISTER_OP_CPU_KERNEL(var_conv_2d, diff --git a/paddle/fluid/operators/warpctc_op.cc b/paddle/fluid/operators/warpctc_op.cc index d7f6714710fc6528f5bb6c87ce845e34d6a791b8..c6b7a6f2d35ca6c64d126163bdd8ff902e1e2f26 100644 --- a/paddle/fluid/operators/warpctc_op.cc +++ b/paddle/fluid/operators/warpctc_op.cc @@ -134,25 +134,26 @@ http://machinelearning.wustl.edu/mlpapers/paper_files/icml2006_GravesFGS06.pdf). } }; -class WarpCTCGradOpDescMaker : public framework::SingleGradOpDescMaker { +template +class WarpCTCGradOpMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; protected: - std::unique_ptr Apply() const override { - std::unique_ptr op(new framework::OpDesc()); + std::unique_ptr Apply() const override { + std::unique_ptr op(new T()); op->SetType("warpctc_grad"); - op->SetInput("WarpCTCGrad", Output("WarpCTCGrad")); - op->SetInput("Logits", Input("Logits")); - op->SetInput(framework::GradVarName("Loss"), OutputGrad("Loss")); + op->SetInput("WarpCTCGrad", this->Output("WarpCTCGrad")); + op->SetInput("Logits", this->Input("Logits")); + op->SetInput(framework::GradVarName("Loss"), this->OutputGrad("Loss")); - op->SetInput("LogitsLength", Input("LogitsLength")); + op->SetInput("LogitsLength", this->Input("LogitsLength")); - op->SetOutput(framework::GradVarName("Logits"), InputGrad("Logits")); + op->SetOutput(framework::GradVarName("Logits"), this->InputGrad("Logits")); - op->SetAttrMap(Attrs()); + op->SetAttrMap(this->Attrs()); return op; } }; @@ -185,7 +186,8 @@ class WarpCTCGradOp : public framework::OperatorWithKernel { namespace ops = paddle::operators; REGISTER_OPERATOR(warpctc, ops::WarpCTCOp, ops::WarpCTCOpMaker, - ops::WarpCTCGradOpDescMaker); + ops::WarpCTCGradOpMaker, + ops::WarpCTCGradOpMaker); REGISTER_OPERATOR(warpctc_grad, ops::WarpCTCGradOp); REGISTER_OP_CPU_KERNEL( warpctc, ops::WarpCTCKernel); diff --git a/paddle/fluid/pybind/imperative.cc b/paddle/fluid/pybind/imperative.cc index 0eb90e03d4688ad59287a4d14b0d750fa0d67d71..275c1f047b47e89874157f02e5d3937665115885 100644 --- a/paddle/fluid/pybind/imperative.cc +++ b/paddle/fluid/pybind/imperative.cc @@ -273,7 +273,10 @@ void BindImperative(py::module *m_ptr) { .def("_grad_ivar", [](const imperative::VarBase &self) { auto &grad_var = self.GradVarBase(); - if (grad_var && grad_var->Var().IsInitialized()) { + auto *tensor = + grad_var->MutableVar()->GetMutable(); + if (grad_var && grad_var->Var().IsInitialized() && + tensor->IsInitialized()) { return grad_var; } else { return std::shared_ptr(nullptr); diff --git a/paddle/fluid/pybind/protobuf.cc b/paddle/fluid/pybind/protobuf.cc index cdbe2c15bff0e45c5b370fb5b77ba57f6e57c2b1..04c1457a05315d27a6557606336fb71e74fd8d35 100644 --- a/paddle/fluid/pybind/protobuf.cc +++ b/paddle/fluid/pybind/protobuf.cc @@ -220,8 +220,16 @@ void BindOpDesc(pybind11::module *m) { .def("input_names", &pd::OpDesc::InputNames) .def("output", &pd::OpDesc::Output) .def("output_names", &pd::OpDesc::OutputNames) - .def("set_input", &pd::OpDesc::SetInput) - .def("set_output", &pd::OpDesc::SetOutput) + .def("set_input", + [](pd::OpDesc &self, const std::string &name, + const std::vector &vec_var_name) { + self.SetInput(name, vec_var_name); + }) + .def("set_output", + [](pd::OpDesc &self, const std::string &name, + const std::vector &vec_var_name) { + self.SetOutput(name, vec_var_name); + }) .def("input_arg_names", &pd::OpDesc::InputArgumentNames) .def("output_arg_names", &pd::OpDesc::OutputArgumentNames) .def("_rename_input", &pd::OpDesc::RenameInput) diff --git a/python/paddle/fluid/tests/custom_op/relu_op.cc b/python/paddle/fluid/tests/custom_op/relu_op.cc index f1a3e29b1163ec0d09e4031142a9891578808890..91ebf9de5d540c3717cab2a5afc416a205c8cff1 100644 --- a/python/paddle/fluid/tests/custom_op/relu_op.cc +++ b/python/paddle/fluid/tests/custom_op/relu_op.cc @@ -48,18 +48,19 @@ class Relu2GradOp : public framework::OperatorWithKernel { } }; -class Relu2GradMaker : public framework::SingleGradOpDescMaker { +template +class Relu2GradMaker : public framework::SingleGradOpMaker { public: - using framework::SingleGradOpDescMaker::SingleGradOpDescMaker; + using framework::SingleGradOpMaker::SingleGradOpMaker; - std::unique_ptr Apply() const override { - auto* op = new framework::OpDesc(); + std::unique_ptr Apply() const override { + auto* op = new T(); op->SetType("relu2_grad"); - op->SetInput("Y", Output("Y")); - op->SetInput(framework::GradVarName("Y"), OutputGrad("Y")); - op->SetAttrMap(Attrs()); - op->SetOutput(framework::GradVarName("X"), InputGrad("X")); - return std::unique_ptr(op); + op->SetInput("Y", this->Output("Y")); + op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y")); + op->SetAttrMap(this->Attrs()); + op->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); + return std::unique_ptr(op); } }; @@ -102,7 +103,11 @@ class Relu2GradKernel : public framework::OpKernel { namespace ops = paddle::operators; using CPU = paddle::platform::CPUDeviceContext; -REGISTER_OPERATOR(relu2, ops::Relu2Op, ops::Relu2OpMaker, ops::Relu2GradMaker); +REGISTER_OPERATOR(relu2, + ops::Relu2Op, + ops::Relu2OpMaker, + ops::Relu2GradMaker, + ops::Relu2GradMaker); REGISTER_OPERATOR(relu2_grad, ops::Relu2GradOp); REGISTER_OP_CPU_KERNEL(relu2, ops::Relu2Kernel, diff --git a/python/paddle/fluid/tests/unittests/test_imperative_auto_prune.py b/python/paddle/fluid/tests/unittests/test_imperative_auto_prune.py index b84b2ac50a8b877b9526ef60575d6175b4fcaf8b..609336e281f2bfe3ccbb6a4f41e7b6e8f4a3137a 100644 --- a/python/paddle/fluid/tests/unittests/test_imperative_auto_prune.py +++ b/python/paddle/fluid/tests/unittests/test_imperative_auto_prune.py @@ -164,6 +164,7 @@ class TestImperativeAutoPrune(unittest.TestCase): v1 = fluid.dygraph.to_variable(value1) v2 = fluid.dygraph.to_variable(value2) loss = case2(v1, v2) + loss.backward() self.assertTrue(case2.fc2._w._ivar._grad_ivar() is None) self.assertTrue(case2.fc1._w._ivar._grad_ivar() is not None) diff --git a/python/paddle/fluid/tests/unittests/test_imperative_resnet.py b/python/paddle/fluid/tests/unittests/test_imperative_resnet.py index eaf82cff35ea74dc2e969c5e8d6763f69b28d628..ebd3387fa41fe1f4a5fcc5700878f12b43001a6e 100644 --- a/python/paddle/fluid/tests/unittests/test_imperative_resnet.py +++ b/python/paddle/fluid/tests/unittests/test_imperative_resnet.py @@ -87,7 +87,8 @@ class ConvBNLayer(fluid.Layer): padding=(filter_size - 1) // 2, groups=groups, act=None, - bias_attr=None) + bias_attr=None, + use_cudnn=False) self._batch_norm = BatchNorm(self.full_name(), num_filters, act=act) @@ -367,6 +368,8 @@ class TestDygraphResnet(unittest.TestCase): static_grad_value[static_grad_name_list[ i - grad_start_pos]] = out[i] + print("static", static_out) + print("dygraph", dy_out) self.assertTrue(np.allclose(static_out, dy_out)) self.assertEqual(len(dy_param_init_value), len(static_param_init_value))