From 8c4573a3cb72e5676e548be4b6a1d9336c4cefe0 Mon Sep 17 00:00:00 2001 From: hong <43953930+phlrain@users.noreply.github.com> Date: Thu, 31 Oct 2019 13:42:45 +0800 Subject: [PATCH] GradMaker for dygraph (#19706) * refactor dygraph,test=develop * fix failed unittest,test=develop * polish code,test=develop * check windows ci error,test=develop try to fix windows ci error by np.allclose,test=develop * polish vlog and profiler, test=develop * try to fix preceding ops order,test=develop * test transformer in windows ci, test=develop * use python c-api to speed up tracer.trace,test=develop * test=develop, fix docker with paddle nccl problem * test=develop, add ut for debug string and gradient_accumulator * test=develop, add tests for layer/gradient_accumulator/prepared_op * test=develop, fix complie error for test_prepared_op * test=develop, add more ut for dygraph * test=develop, create API.spec for dygraph api change * optimize grad maker; test=develop * optimize grad maker * test * grad make optim; test=develop * fix unittest bugs; test=develop * add dygraph grad op maker and split_op * grad op maker refactor; test=develop * add dygraph grad maker; test=develop * fix op deformable_conv_v1_op bug; test=develop * fix deformable_conv prroi pool bugs; * fix new op grad op maker bug; test=develop * fix split by ref bug; test=develop * fix dygraph auto prune bug; test=develop * fix test_trace bug; test=develop * fix fused emb seq pool bug; test=develop * remove useless code in op_desc file; test=develop * remove useless code, StrVarBaseNode; test=develop * fix review issues; test=develop * fix rank_loss grad maker; test=develop * remove flag in VarBase; test=develop * fix distributed_notify_op compile bug ; test=develop * fix reshape op double grad; test=develop * fix expand as op; test=develop * add impertive type_defs.h for demo_train; test=develop * fix inference lib cmake; test=develop * fix inference lib; test=develop * fix infernce_lib; test=develop * fix inference cmake; test=develop * fix inference lib; test=develop * fix inference lib; test=develop * remove condition dygraph grad maker, modify local name; test=develop * fix split grad maker bug; test=develop * fix pyramid_op bug; test=develop * change travis time out limit; test=develop * restore travis; test=develop * change timeout limit; test=develop --- .travis.yml | 1 + cmake/inference_lib.cmake | 7 + paddle/fluid/framework/details/op_registry.h | 21 +- paddle/fluid/framework/grad_op_desc_maker.h | 78 ++++++- .../conv_bias_mkldnn_fuse_pass_tester.cc | 1 + .../ir/mkldnn/cpu_quantize_pass_tester.cc | 2 + paddle/fluid/framework/op_desc.h | 1 + paddle/fluid/framework/op_info.h | 19 ++ paddle/fluid/framework/op_registry.h | 3 +- paddle/fluid/framework/operator.cc | 2 +- paddle/fluid/framework/operator.h | 2 + paddle/fluid/framework/type_defs.h | 7 + paddle/fluid/imperative/dygraph_grad_maker.h | 153 +++++++++++++ paddle/fluid/imperative/engine.cc | 8 +- paddle/fluid/imperative/layer.cc | 34 ++- paddle/fluid/imperative/layer.h | 57 ++++- paddle/fluid/imperative/prepared_operator.cc | 1 + paddle/fluid/imperative/tests/CMakeLists.txt | 2 +- paddle/fluid/imperative/tests/test_tracer.cc | 90 +++++++- paddle/fluid/imperative/tracer.cc | 211 +++++------------- paddle/fluid/imperative/tracer.h | 1 - paddle/fluid/operators/activation_op.cc | 166 ++++++++------ .../operators/add_position_encoding_op.cc | 24 +- paddle/fluid/operators/affine_channel_op.cc | 29 +-- paddle/fluid/operators/affine_grid_op.cc | 24 +- paddle/fluid/operators/arg_max_op.cc | 7 +- paddle/fluid/operators/arg_min_op.cc | 7 +- paddle/fluid/operators/argsort_op.cc | 6 +- .../fluid/operators/array_to_lod_tensor_op.cc | 22 +- paddle/fluid/operators/assign_op.cc | 20 +- paddle/fluid/operators/assign_value_op.cc | 6 +- .../fluid/operators/average_accumulates_op.cc | 8 +- paddle/fluid/operators/batch_norm_op.cc | 55 +++-- paddle/fluid/operators/batch_norm_op.h | 12 - .../fluid/operators/beam_search_decode_op.cc | 12 +- .../operators/bilinear_tensor_product_op.cc | 39 ++-- paddle/fluid/operators/bpr_loss_op.cc | 22 +- paddle/fluid/operators/cast_op.cc | 23 +- paddle/fluid/operators/center_loss_op.cc | 22 +- paddle/fluid/operators/clip_op.cc | 21 +- .../operators/collective/c_allgather_op.cc | 19 +- .../collective/c_allreduce_sum_op.cc | 19 +- .../collective/c_reducescatter_op.cc | 15 +- paddle/fluid/operators/concat_op.cc | 22 +- .../fluid/operators/controlflow/compare_op.cc | 25 ++- .../controlflow/conditional_block_infer_op.cc | 8 +- .../controlflow/conditional_block_op.cc | 33 +-- paddle/fluid/operators/controlflow/feed_op.cc | 8 +- .../fluid/operators/controlflow/fetch_op.cc | 8 +- .../operators/controlflow/get_places_op.cc | 8 +- .../fluid/operators/controlflow/logical_op.cc | 6 +- .../controlflow/tensor_array_read_write_op.cc | 45 ++-- .../fluid/operators/controlflow/while_op.cc | 32 +-- paddle/fluid/operators/conv_op.cc | 156 +++++++------ paddle/fluid/operators/conv_shift_op.cc | 24 +- paddle/fluid/operators/conv_transpose_op.cc | 38 ++-- paddle/fluid/operators/cos_sim_op.cc | 6 +- paddle/fluid/operators/crop_op.cc | 24 +- paddle/fluid/operators/crop_tensor_op.cc | 28 +-- paddle/fluid/operators/cross_entropy_op.cc | 46 ++-- paddle/fluid/operators/ctc_align_op.cc | 6 +- paddle/fluid/operators/cudnn_lstm_op.cc | 44 ++-- paddle/fluid/operators/cumsum_op.cc | 25 ++- paddle/fluid/operators/cvm_op.cc | 23 +- paddle/fluid/operators/data_norm_op.cc | 46 ++-- paddle/fluid/operators/deformable_conv_op.cc | 37 +-- .../fluid/operators/deformable_conv_v1_op.cc | 29 +-- .../operators/deformable_psroi_pooling_op.cc | 34 +-- paddle/fluid/operators/delete_var_op.cc | 10 +- .../detection/anchor_generator_op.cc | 7 +- .../operators/detection/bipartite_match_op.cc | 7 +- .../fluid/operators/detection/box_clip_op.cc | 6 +- .../fluid/operators/detection/box_coder_op.cc | 6 +- .../detection/box_decoder_and_assign_op.cc | 8 +- .../detection/collect_fpn_proposals_op.cc | 8 +- .../detection/density_prior_box_op.cc | 7 +- .../detection/distribute_fpn_proposals_op.cc | 8 +- .../detection/generate_mask_labels_op.cc | 8 +- .../detection/generate_proposal_labels_op.cc | 8 +- .../detection/generate_proposals_op.cc | 7 +- .../operators/detection/iou_similarity_op.cc | 7 +- .../detection/mine_hard_examples_op.cc | 7 +- .../operators/detection/multiclass_nms_op.cc | 14 +- .../detection/polygon_box_transform_op.cc | 8 +- .../fluid/operators/detection/prior_box_op.cc | 6 +- .../retinanet_detection_output_op.cc | 8 +- .../detection/roi_perspective_transform_op.cc | 33 +-- .../detection/rpn_target_assign_op.cc | 15 +- .../detection/sigmoid_focal_loss_op.cc | 25 ++- .../operators/detection/target_assign_op.cc | 6 +- .../fluid/operators/detection/yolo_box_op.cc | 6 +- .../operators/detection/yolov3_loss_op.cc | 33 +-- paddle/fluid/operators/detection_map_op.cc | 6 +- paddle/fluid/operators/diag_op.cc | 6 +- .../distributed_ops/checkpoint_notify_op.cc | 9 +- .../distributed_ops/distributed_notify_op.cc | 9 +- .../operators/distributed_ops/fake_init_op.cc | 8 +- .../distributed_ops/fetch_barrier_op.cc | 8 +- .../operators/distributed_ops/prefetch_op.cc | 8 +- .../operators/distributed_ops/recv_op.cc | 7 +- .../distributed_ops/send_barrier_op.cc | 8 +- .../operators/distributed_ops/send_op.cc | 7 +- .../distributed_ops/split_byref_op.cc | 3 +- paddle/fluid/operators/dropout_op.cc | 20 +- paddle/fluid/operators/edit_distance_op.cc | 6 +- .../elementwise/elementwise_add_op.cc | 31 +-- .../elementwise/elementwise_div_op.cc | 59 ++--- .../elementwise/elementwise_max_op.cc | 24 +- .../elementwise/elementwise_min_op.cc | 24 +- .../elementwise/elementwise_mul_op.cc | 59 ++--- .../operators/elementwise/elementwise_op.h | 99 ++++---- .../elementwise/elementwise_pow_op.cc | 24 +- .../elementwise/elementwise_sub_op.cc | 31 +-- paddle/fluid/operators/expand_as_op.cc | 22 +- paddle/fluid/operators/expand_op.cc | 24 +- paddle/fluid/operators/eye_op.cc | 6 +- paddle/fluid/operators/fake_dequantize_op.cc | 18 +- paddle/fluid/operators/fake_quantize_op.cc | 53 +++-- paddle/fluid/operators/fc_op.cc | 7 +- .../fill_constant_batch_size_like_op.cc | 11 +- paddle/fluid/operators/fill_constant_op.cc | 8 +- paddle/fluid/operators/fill_op.cc | 7 +- paddle/fluid/operators/fill_zeros_like_op.cc | 9 +- paddle/fluid/operators/filter_by_instag_op.cc | 24 +- paddle/fluid/operators/flatten_op.cc | 31 +-- paddle/fluid/operators/fsp_op.cc | 6 +- .../fluid/operators/fused/conv_fusion_op.cc | 8 +- .../fused/fused_elemwise_activation_op.cc | 21 +- .../fused/fused_embedding_seq_pool_op.cc | 30 +-- .../fused_fc_elementwise_layernorm_op.cc | 9 +- .../fused/fusion_conv_inception_op.cc | 8 +- .../fused/fusion_seqpool_cvm_concat_op.cc | 8 +- .../fusion_transpose_flatten_concat_op.cc | 9 +- paddle/fluid/operators/gather_nd_op.cc | 22 +- paddle/fluid/operators/gather_op.cc | 22 +- .../gaussian_random_batch_size_like_op.cc | 12 +- paddle/fluid/operators/grid_sampler_op.cc | 26 ++- paddle/fluid/operators/group_norm_op.cc | 33 +-- paddle/fluid/operators/gru_op.cc | 6 +- paddle/fluid/operators/gru_unit_op.cc | 41 ++-- .../operators/hierarchical_sigmoid_op.cc | 43 ++-- paddle/fluid/operators/hinge_loss_op.cc | 22 +- paddle/fluid/operators/huber_loss_op.cc | 22 +- paddle/fluid/operators/im2sequence_op.cc | 20 +- paddle/fluid/operators/increment_op.cc | 21 +- paddle/fluid/operators/instance_norm_op.cc | 45 +--- paddle/fluid/operators/instance_norm_op.h | 48 +++- paddle/fluid/operators/interpolate_op.cc | 40 ++-- paddle/fluid/operators/is_empty_op.cc | 6 +- paddle/fluid/operators/isfinite_op.cc | 29 +-- paddle/fluid/operators/kldiv_loss_op.cc | 24 +- paddle/fluid/operators/l1_norm_op.cc | 20 +- paddle/fluid/operators/label_smooth_op.cc | 18 +- paddle/fluid/operators/layer_norm_op.cc | 34 +-- paddle/fluid/operators/linear_chain_crf_op.cc | 38 ++-- paddle/fluid/operators/lod_array_length_op.cc | 8 +- paddle/fluid/operators/lod_rank_table_op.cc | 12 +- paddle/fluid/operators/lod_reset_op.cc | 21 +- .../fluid/operators/lod_tensor_to_array_op.cc | 22 +- paddle/fluid/operators/log_loss_op.cc | 23 +- .../fluid/operators/lookup_sparse_table_op.cc | 9 +- paddle/fluid/operators/lookup_table_op.cc | 22 +- paddle/fluid/operators/lookup_table_v2_op.cc | 23 +- paddle/fluid/operators/lrn_op.cc | 7 +- paddle/fluid/operators/lstm_op.cc | 48 ++-- paddle/fluid/operators/lstm_unit_op.cc | 6 +- paddle/fluid/operators/lstmp_op.cc | 55 ++--- paddle/fluid/operators/margin_rank_loss_op.cc | 24 +- .../fluid/operators/match_matrix_tensor_op.cc | 8 +- paddle/fluid/operators/matmul_op.cc | 26 ++- paddle/fluid/operators/max_sequence_len_op.cc | 10 +- paddle/fluid/operators/maxout_op.cc | 6 +- paddle/fluid/operators/mean_iou_op.cc | 6 +- paddle/fluid/operators/mean_op.cc | 20 +- paddle/fluid/operators/merge_lod_tensor_op.cc | 32 +-- paddle/fluid/operators/metrics/accuracy_op.cc | 6 +- .../fluid/operators/modified_huber_loss_op.cc | 28 +-- paddle/fluid/operators/mul_op.cc | 60 ++--- paddle/fluid/operators/multiplex_op.cc | 20 +- paddle/fluid/operators/nccl/nccl_op.cc | 10 +- paddle/fluid/operators/nce_op.cc | 8 +- paddle/fluid/operators/norm_op.cc | 22 +- paddle/fluid/operators/one_hot_op.cc | 6 +- paddle/fluid/operators/one_hot_v2_op.cc | 6 +- .../operators/optimizers/lars_momentum_op.cc | 8 +- .../fluid/operators/optimizers/momentum_op.cc | 8 +- paddle/fluid/operators/optimizers/sgd_op.cc | 7 +- paddle/fluid/operators/optimizers/sgd_op.cu | 4 + paddle/fluid/operators/pad2d_op.cc | 26 ++- .../fluid/operators/pad_constant_like_op.cc | 23 +- paddle/fluid/operators/pad_op.cc | 21 +- paddle/fluid/operators/pixel_shuffle_op.cc | 20 +- paddle/fluid/operators/pool_op.cc | 14 +- paddle/fluid/operators/pool_with_index_op.cc | 16 +- paddle/fluid/operators/prelu_op.cc | 6 +- paddle/fluid/operators/print_op.cc | 22 +- paddle/fluid/operators/prroi_pool_op.cc | 26 ++- paddle/fluid/operators/psroi_pool_op.cc | 22 +- paddle/fluid/operators/pull_box_sparse_op.cc | 21 +- paddle/fluid/operators/pyramid_hash_op.cc | 29 +-- paddle/fluid/operators/random_crop_op.cc | 7 +- paddle/fluid/operators/rank_loss_op.cc | 26 ++- .../reader/create_custom_reader_op.cc | 10 +- paddle/fluid/operators/reader/read_op.cc | 7 +- .../operators/reader/reader_op_registry.h | 25 ++- paddle/fluid/operators/recurrent_op.cc | 20 +- .../operators/reduce_ops/reduce_mean_op.cc | 44 +++- paddle/fluid/operators/reduce_ops/reduce_op.h | 31 +-- .../operators/reduce_ops/reduce_sum_op.cc | 21 +- .../reorder_lod_tensor_by_rank_op.cc | 27 +-- paddle/fluid/operators/reshape_op.cc | 58 ++--- paddle/fluid/operators/reverse_op.cc | 21 +- .../fluid/operators/rnn_memory_helper_op.cc | 10 +- paddle/fluid/operators/roi_align_op.cc | 22 +- paddle/fluid/operators/roi_pool_op.cc | 24 +- paddle/fluid/operators/row_conv_op.cc | 24 +- paddle/fluid/operators/sample_logits_op.cc | 28 ++- paddle/fluid/operators/sampling_id_op.cc | 6 +- paddle/fluid/operators/scale_op.cc | 21 +- paddle/fluid/operators/scatter_nd_add_op.cc | 25 ++- paddle/fluid/operators/scatter_op.cc | 25 ++- paddle/fluid/operators/selu_op.cc | 21 +- .../sequence_ops/sequence_concat_op.cc | 20 +- .../sequence_ops/sequence_conv_op.cc | 33 +-- .../sequence_ops/sequence_expand_as_op.cc | 29 +-- .../sequence_ops/sequence_expand_op.cc | 22 +- .../sequence_ops/sequence_mask_op.cc | 8 +- .../operators/sequence_ops/sequence_pad_op.cc | 20 +- .../sequence_ops/sequence_pool_op.cc | 27 ++- .../sequence_ops/sequence_reshape_op.cc | 25 ++- .../sequence_ops/sequence_reverse_op.cc | 3 +- .../sequence_ops/sequence_reverse_op.h | 15 +- .../sequence_ops/sequence_scatter_op.cc | 25 ++- .../sequence_ops/sequence_slice_op.cc | 25 ++- .../sequence_ops/sequence_softmax_op.cc | 7 +- .../sequence_topk_avg_pooling_op.cc | 34 +-- .../sequence_ops/sequence_unpad_op.cc | 21 +- paddle/fluid/operators/shape_op.cc | 6 +- .../fluid/operators/shrink_rnn_memory_op.cc | 23 +- paddle/fluid/operators/shuffle_channel_op.cc | 19 +- .../sigmoid_cross_entropy_with_logits_op.cc | 32 +-- paddle/fluid/operators/sign_op.cc | 19 +- paddle/fluid/operators/similarity_focus_op.cc | 7 +- paddle/fluid/operators/size_op.cc | 6 +- paddle/fluid/operators/slice_op.cc | 30 +-- paddle/fluid/operators/smooth_l1_loss_op.cc | 28 +-- paddle/fluid/operators/softmax_op.cc | 23 +- .../softmax_with_cross_entropy_op.cc | 26 ++- paddle/fluid/operators/space_to_depth_op.cc | 20 +- paddle/fluid/operators/spectral_norm_op.cc | 24 +- paddle/fluid/operators/split_lod_tensor_op.cc | 32 +-- paddle/fluid/operators/split_op.cc | 5 +- paddle/fluid/operators/split_op.h | 19 +- .../fluid/operators/split_selected_rows_op.cc | 20 +- paddle/fluid/operators/spp_op.cc | 6 +- .../fluid/operators/squared_l2_distance_op.cc | 32 +-- paddle/fluid/operators/squared_l2_norm_op.cc | 21 +- paddle/fluid/operators/squeeze_op.cc | 29 ++- paddle/fluid/operators/stack_op.cc | 3 +- paddle/fluid/operators/stack_op.h | 15 +- paddle/fluid/operators/strided_slice_op.cc | 34 +-- paddle/fluid/operators/sum_op.cc | 31 ++- paddle/fluid/operators/sync_batch_norm_op.cc | 42 +++- .../teacher_student_sigmoid_loss_op.cc | 30 +-- paddle/fluid/operators/temporal_shift_op.cc | 19 +- .../operators/tensor_array_to_tensor_op.cc | 9 +- paddle/fluid/operators/top_k_op.cc | 6 +- paddle/fluid/operators/transpose_op.cc | 28 ++- paddle/fluid/operators/tree_conv_op.cc | 26 ++- paddle/fluid/operators/unfold_op.cc | 20 +- .../uniform_random_batch_size_like_op.cc | 12 +- paddle/fluid/operators/uniform_random_op.cc | 10 +- paddle/fluid/operators/unpool_op.cc | 7 +- paddle/fluid/operators/unsqueeze_op.cc | 29 ++- paddle/fluid/operators/unstack_op.cc | 18 +- paddle/fluid/operators/var_conv_2d_op.cc | 6 +- paddle/fluid/operators/warpctc_op.cc | 24 +- paddle/fluid/pybind/imperative.cc | 5 +- paddle/fluid/pybind/protobuf.cc | 12 +- .../paddle/fluid/tests/custom_op/relu_op.cc | 25 ++- .../unittests/test_imperative_auto_prune.py | 1 + .../tests/unittests/test_imperative_resnet.py | 5 +- 282 files changed, 3614 insertions(+), 2539 deletions(-) create mode 100644 paddle/fluid/imperative/dygraph_grad_maker.h diff --git a/.travis.yml b/.travis.yml index 87de895ddad..ad1cc0ae14a 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 161bb29c818..e2499fd464a 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 0f03ca51da7..4d6ad876240 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 25a64b69ae8..5fda027453c 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 427d7bc9aeb..6ebe642a7d3 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 0a689441867..947f4fd37a9 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 2f6fb9e2984..ebdb5386962 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 1297d8de81f..79a6a06abb3 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 3f14f47f0dd..221ab352ad3 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 6bcff6b059a..c2851f9fd37 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 ab956a9474c..6a9af6af315 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 7f1bfb5d9a8..2397bfde3d1 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 00000000000..c2107f0a89f --- /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 877e6ceb6a4..0d9edce4db8 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 8a5db26d7d7..573f75e1de8 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 4ef22c97d0d..a0fa11a7250 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 6f8ee92bdfc..b3ec5af445c 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 f32f0a1726f..2b2d91485fd 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 9ef13a5d45b..4e97f97853e 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 ce107daa158..7b160cd22b3 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 7bddea53f15..b58f2a81747 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 be4786fadaf..60cf5645189 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 61a9fa76507..30dfd683a04 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 6040ed7550d..420ef4d75ac 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 c46b4260115..959af025c33 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 7fe9a0df746..fd7fa17ac9a 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 23b24735cd0..74fc3292746 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 d25160f4232..57c2a3ba7b8 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 7b5a270ee07..0f258f4a5e7 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 c2b3c818c65..315982ec8fb 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 a757916be7f..456cbee923a 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 273df31fc80..5b3dbcd65ec 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 546605c8dba..bc0f16a9662 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 6c7dbe0db4e..4746a1d2cf1 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 4cef49280df..5eec87887ac 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 f2c30cd7e8c..235a8deb99b 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 1ad02713049..c0985abecac 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 0c517cc757c..c7a6b50b2fa 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 0b6ce823973..f0c0a5e619f 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 408f960b53b..121fec1bb27 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 18c8f5d6423..8e54ec4ab21 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 c80c585a832..51d6fb2b6e8 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 1194ac71b32..959c164dec2 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 820d3e3df70..ceb25fad2c2 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 5d3f9b43f8c..7b359ff0beb 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 8ad2f79389d..78acd8beb3f 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 260b5672b4f..d1751ba6fa2 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 0dfed7f5cc1..1e3af06cea2 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 39fdf07f051..93b4b2d474e 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 fa77f97419b..6bbe0cefbd6 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 f97b7f2dc9b..95c16ebc949 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 063f30d2de8..1afc8f6d73f 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 00870c691c2..0953256b971 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 cf720cc627c..c8e45f9ec4e 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 ddbd6f395fe..6c161d92a0b 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 4ba330447e2..aead007367e 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 289bb5d2ddd..aaabc59e25c 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 f42463582f8..6fa9f87346a 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 e4a314cea06..83047ac8850 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 d6da40ddfe6..ab5d45b800d 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 9982230495d..be386a8eb84 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 73e04da3b0d..ed1e06be7f9 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 5302b822d6b..ab81a2873bf 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 7675a6acf7e..327d75608ba 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 6d1168c3ae8..dc116ec69a2 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 1eedcc010f2..32951a447f6 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 8bef1a0b748..c76bb6c152c 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 dd2f700901b..e76649e8283 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 89416f7ab5d..ec60569be20 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 d3287249166..a3030dbdd24 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 785a2072631..de4579919c3 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 3aa766559a5..9e4c7f1619a 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 de361267744..070c822a7ed 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 976aa317b88..95670a0d0a1 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 8c53eb5da2f..b314275174a 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 f9ea1dc67d9..cfa5f467f0d 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 ce37e73b750..2976c3ff4c8 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 bd18d77174f..db69cf0301c 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 873d44b27e2..668459f0a3d 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 bcbd7e1e203..1a9b62f4f6a 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 9c89b7ca9af..b56c678099e 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 c8701d28101..24d59c94cb4 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 28380a04ba1..eb9a3c70483 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 4b3bc2edb58..ab134e20917 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 8d821739f6f..f4f3bcd667a 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 a79a7608ea9..a78a46c3499 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 20f0012276a..b220ea540a8 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 67aab192fbe..374d73839ad 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 eb59c943e4b..faa1258b9f5 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 b2487b13523..7c187066c66 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 602efd7b80a..36218e7a0da 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 d6cd3171ee3..5ffcfc0458f 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 cfd159a2cca..617edd781db 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 5fb18a1d695..1a3dd006c7e 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 a09bff351fc..cd7e4363fa0 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 5e15b11655d..58c1b6486b0 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 5ee35e0458a..b56ab1d5fd6 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 8a752690857..f0ed7e19254 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 52b96d5f8ef..c6395289f8f 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 30a161fe256..a2b7f2f312b 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 558d0090d73..7e4f3647b37 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 6fff3317f22..0f5af6973ab 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 43980107c14..79d9c272e8b 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 0e060c3a1a3..597d446b00a 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 a854d470ddd..e12206cccc2 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 922e6904ed7..536e6cba404 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 507b5a4ed7a..4459555102c 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 40826c7fefd..2b1b7c2ee27 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 9f00fc445a4..9bea93d6cdd 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 d843fb4fd11..87dc15fadcc 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 67babe64044..720d5d25642 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 d3e225a7c07..46e4e159ac6 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 48979348218..480f41030f3 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 204a93df23d..002623c1b17 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 41147b77ee0..fadd65fad30 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 40848b96335..e7fd1a44734 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 4a8937ba1c7..e01adae4dd8 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 53cdcc99226..085356f77df 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 f831d1173e2..5a3e1bb7fda 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 404c2a92a47..087463df91d 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 4f7cfcf112a..a13eff7f8da 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 107f83e3f88..00cc1f6e0b6 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 a48c901f9e6..b156246f04b 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 c27bb1606b3..320e132d222 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 0706f9ce376..020b03e3eea 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 dd74d278111..30dd35db9ed 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 9a156147aa4..e60534f0ef8 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 727e135c356..ee2891f9bbc 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 7c5d0c71226..ea7d6a93d1b 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 e18ac13d345..60092cfff68 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 0a245bb0505..f64e4f134d6 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 39356c9afcc..3127c0259a5 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 b2a4029c8f6..f871615d0bd 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 075be1caf48..1f85e30811b 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 daf85139103..ab7403a8ba5 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 5338889363a..244de0e3552 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 e184ff14a55..7cb85d636fb 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 9797160c962..4be1c3e5861 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 e3beedcf10b..ddb6588ab99 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 a27fcf628cc..a54d52ae45e 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 b6cfa9cc43c..e19a39cc82c 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 9b9a5207531..39cf56f7c0f 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 0fa7322fbd6..e3ee551c5ce 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 f0ffc970668..2d68965afae 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 bb6b37e64e4..a67044849c7 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 509c1ff038d..9ff6f09ad01 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 cbe9865673b..cc753b1f91f 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 109e96fb7ba..1f78675060e 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 1312eecfa44..f8c584163fb 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 d5976e7f4ae..8492ac915b8 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 2696d0bef9e..12fd07f6de7 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 6d0af573184..b76ccbcfce0 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 1aac60ef36c..3e77f0922b4 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 32d9f09e3a2..a0b803238e4 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 e4551b8ba68..2553b9fb227 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 0a43ac0c52f..8e16834e843 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 190a7cdf12f..baa709b9e49 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 9480f0b2511..fbabd358306 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 0048c75ccf0..caea24022c4 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 4840a7ac1e7..ef3030d9be2 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 c1d45bb7a0d..feed5a65d6b 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 f0cffa4e1fe..4aadd4b8c00 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 d5b092ec99d..19c33b48c1d 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 43af877085b..ef0281436e5 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 47d695475c2..e3821f9dc20 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 68e204983e8..b71735592f3 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 fca35325517..12ff6a9b503 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 d30f396f9c1..2aeb68ed901 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 e8a9b38c9c4..587d6bdc0d8 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 b1e69f375d3..3ac9c584727 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 c05c1a282c2..e051db8b89d 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 615b9ea4847..4bf46edad61 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 e19ac59ee57..108002d85c7 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 67154447d1b..e832aca3c64 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 937b987b88c..1178b2cc03a 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 4029119ba57..0c375eb5de0 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 119aa688839..9de7717b8fc 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 843f0a68e1d..961a80398a2 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 6a0ae0dede6..8cf43be35ce 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 0f26e3953fe..86816a76780 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 81fbe3e5142..ba0108304b9 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 e4d50db30a3..40f2dc697b2 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 62f85496f9b..94a42bef5a3 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 126b665dd4d..5f0500d2faa 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 111f104d273..a0dc387fb67 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 dcc6ce41b27..aad5677b970 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 40b9d03f853..ebe7814aa7e 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 461db5fdc94..71919667ba1 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 1c4bf7035ef..d408275d8e5 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 36dc8b0dbb3..b98f201e8a1 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 59ba660af79..d34596c2ded 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 6ece163f697..817ad336cf6 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 d8c2ccaa960..f8148f946fc 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 364f3689f9f..5408e7bf0d3 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 f686e5293b0..37e062982e1 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 c11d09350a4..85e15d0ed1b 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 a9128fbd28d..4bbd0e2b793 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 3af3fb49675..972a31a62cb 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 e0b63d2ead7..363f4dcf4ad 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 15911a51a2c..acb6ca84ca3 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 a0fe1cae4e6..3894b5a46a6 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 975f7b991f8..a7d815367f3 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 bd4e3e293da..3da7c88f1fe 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 de0c34ad32e..35a0dacaec2 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 c6751463e73..88e1b479f1e 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 e549d2bddfe..b41a7394407 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 14bb2cf0013..9949fd8a5be 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 b3b5038b032..32a7848d0ed 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 9a32a02c11b..df4fbb279f8 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 a20f7d231fa..1c3b3d3c2ff 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 f360ae3cbf4..0ef8ae8b6a0 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 a57266690b0..f84639b7a6c 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 0515768a630..2b71ffc635f 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 d66b0a65fe0..dd85e4a12f5 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 962b5dbc505..c0dfc94eede 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 ece3ff6e705..bf0739557bc 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 383e7940fa5..e055962f505 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 ba65832dcea..e86724dd569 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 b3f43a28dff..d763f74d4ee 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 f71d844d9e9..09550efefeb 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 118c8ce0b11..319fdec06ac 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 89c1fe83483..ce731c99b5b 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 c7284d0950c..944ca37c7fa 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 90f794ab5ff..3ddbebcd6af 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 cd0170dd1b4..e9097ee258a 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 de5a0aa45bc..65b8839a2b1 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 bf82044ad47..d2459570c92 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 5421f35662b..e1d8911c32f 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 dfbbf5f1569..739b26b0e3e 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 12d0f8095ee..d0078c0321d 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 7f9dbbf7eca..0700077ac69 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 537184d8b52..9e31a81c435 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 12729f43247..33ad5d828b7 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 06b16152ef9..b442c41eed1 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 558d180cfba..dbb01a5c367 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 3715dd114d6..4a0f41ae54d 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 586a65091df..c9b0795ddb0 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 48da765416f..5540428ba5f 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 c453b03dddf..a4ef2a2369a 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 6837856a6da..3793a3d43fe 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 e49ce7c4872..3e3c9cf98fd 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 0eda6fbef32..ca7f36205a2 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 9adb4de01cb..4caa07dff87 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 fbfe3331188..14bf314a152 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 09c08f23307..557cdad3d09 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 727d67c2fba..ebb299ba1f3 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 e2c2998095e..133be773ac7 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 71049c58e16..2cdcaeaf09d 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 870adfbaa79..fedd8543ae8 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 5277440f5b6..997d3fe4e3c 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 77d630235f7..552b27df1b6 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 88dfebc0cff..b0217d93e92 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 a2a96b72f09..e9ed900ea0f 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 6c0b195decc..47683fabd33 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 9d2deb678ec..81a8a7beaed 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 a7e10457fd7..76817f302c6 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 9345b495415..b2e46cccfc4 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 9ebf166d703..9cb391c048a 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 5cd7a786363..c64e8beb254 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 27b66250d73..33eef7b075c 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 d6cf27fd779..a134541dd78 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 7823b9d8501..e237a9a6503 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 6663d3f5571..7270c5fc5be 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 82741077d9c..e6f78f52d68 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 fdf5148eb87..436bb5d7221 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 eab6d437d47..de22faa2d2d 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 0c72275c5bb..0ed0b558fdc 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 99907e066b2..6f0f5230019 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 598c9042cfb..f90bb4be034 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 e81d8a22fee..566fe662156 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 0693df843eb..fae63c90bb2 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 22f2a0fc355..b0a458cbb87 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 204aa1fa670..737f9d929e9 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 232075203a0..32967f8af50 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 d7f6714710f..c6b7a6f2d35 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 0eb90e03d46..275c1f047b4 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 cdbe2c15bff..04c1457a053 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 f1a3e29b116..91ebf9de5d5 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 b84b2ac50a8..609336e281f 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 eaf82cff35e..ebd3387fa41 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)) -- GitLab