remove condition dygraph grad maker, modify local name; test=develop

Author: phlrain

paddle/fluid/imperative/layer.cc

@@ -264,8 +264,7 @@ void OpBase::CreateOperatorBase() {
   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_);
 }
 
 void OpBase::Run(const NameVarBaseMap& ins, const NameVarBaseMap& outs) {

paddle/fluid/imperative/layer.h

@@ -384,8 +384,8 @@ class OpBase : public std::enable_shared_from_this<OpBase> {
     return grad_pending_ops_;
   }
 
-  void SetGradPendingOps(std::vector<OpBase*>* vec_temp) {
-    grad_pending_ops_.swap(*vec_temp);
+  void SetGradPendingOps(std::vector<OpBase*> vec_temp) {
+    grad_pending_ops_.swap(vec_temp);
   }
 
   void InsertGradPendingOps(OpBase* op) { grad_pending_ops_.emplace_back(op); }
@@ -426,11 +426,11 @@ class OpBase : public std::enable_shared_from_this<OpBase> {
   void SetType(const std::string& type) { type_ = type; }
   void SetInput(const std::string& name,
                 std::vector<std::shared_ptr<VarBase>> vec_var_base) {
-    ins_.emplace(name, vec_var_base);
+    ins_[name] = std::move(vec_var_base);
   }
   void SetOutput(const std::string& name,
                  std::vector<std::shared_ptr<VarBase>> vec_var_base) {
-    outs_.emplace(name, 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) {

paddle/fluid/imperative/tracer.cc

@@ -94,14 +94,14 @@ void Tracer::TraceBackward(const std::shared_ptr<OpBase>& fwd_op,
   size_t grad_op_num = grad_op_bases_.size();
 
   std::set<VarBase*> set_input_vars;
-  for (auto& grad_in_it : ins) {
-    for (auto& var_base_it : grad_in_it.second) {
+  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& grad_out_it : outs) {
-    for (auto& var_base_it : grad_out_it.second) {
+  for (auto& fwd_out_it : outs) {
+    for (auto& var_base_it : fwd_out_it.second) {
       set_input_vars.insert(var_base_it.get());
     }
   }
@@ -148,7 +148,7 @@ void Tracer::TraceBackward(const std::shared_ptr<OpBase>& fwd_op,
     std::vector<OpBase*> vec_preceding_ops(visited_preceding_ops.begin(),
                                            visited_preceding_ops.end());
 
-    grad_op->SetGradPendingOps(&vec_preceding_ops);
+    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);

paddle/fluid/operators/controlflow/conditional_block_op.cc

@@ -204,7 +204,6 @@ class ConditionalBlockGradMaker : public framework::SingleGradOpMaker<T> {
 namespace ops = paddle::operators;
 REGISTER_OPERATOR(conditional_block, ops::ConditionalBlockOp,
                   ops::ConditionalBlockOpProtoMaker,
-                  ops::ConditionalBlockGradMaker<paddle::framework::OpDesc>,
-                  ops::ConditionalBlockGradMaker<paddle::imperative::OpBase>);
+                  ops::ConditionalBlockGradMaker<paddle::framework::OpDesc>);
 REGISTER_OPERATOR(conditional_block_grad, ops::ConditionalBlockGradOp,
                   ops::ConditionalBlockGradInferShape);