赛题八：paddleviz能力扩展——Tensor信息展示

paddle/fluid/eager/accumulation/accumulation_node.cc

@@ -132,21 +132,26 @@ GradNodeAccumulation::operator()(
   if (ReduceHooksRegistered()) {
     ApplyReduceHooks();
   }
+
   VLOG(3) << "Finish AD API Grad: GradNodeAccumulation";
   if (VLOG_IS_ON(4)) {
     const char* INPUT_PRINT_TEMPLATE = "{ Input: [%s], Output: [%s] } ";
 
     std::string input_str = "";
     std::string output_str = "";
+
     const char* TENSOR_OUT_GRAD_TEMPLATE = "(grads[0][0], [%s]), ";
     std::string input_out_grad_str = paddle::string::Sprintf(
-        TENSOR_OUT_GRAD_TEMPLATE, egr::EagerUtils::TensorStr(grads[0][0]));
+         TENSOR_OUT_GRAD_TEMPLATE, egr::EagerUtils::TensorStr(grads[0][0]));
+    input_str += input_out_grad_str;
     const char* TENSOR_X_GRAD_TEMPLATE = "(grad_out, [%s]), ";
     std::string output_x_grad_str = paddle::string::Sprintf(
         TENSOR_X_GRAD_TEMPLATE, egr::EagerUtils::TensorStr(grad_out));
     output_str += output_x_grad_str;
     VLOG(4) << paddle::string::Sprintf(
         INPUT_PRINT_TEMPLATE, input_str, output_str);
+    VLOG(6) << "gradnode_ptr = " << this << ", " << paddle::string::Sprintf(
+        INPUT_PRINT_TEMPLATE, input_str, output_str);
   }
   return {{grad_out}};
 }

paddle/fluid/eager/api/manual/eager_manual/nodes/add_n_node.cc

@@ -72,6 +72,30 @@ AddNGradNodeFinal::operator()(
     egr::CheckTensorHasNanOrInf("add_n_grad", returns);
   }
 
+  if (VLOG_IS_ON(4)) {
+    const char *INPUT_PRINT_TEMPLATE = "{ Input: [%s],  \n Output: [%s] } ";
+    std::string input_str = "";
+    std::string output_str = "";
+
+    const char *TENSOR_INPUT_TEMPLATE = " \n( x , [%s]), ";
+    std::string input_x_str =
+        paddle::string::Sprintf(TENSOR_INPUT_TEMPLATE, egr::EagerUtils::TensorStr(x));
+    input_str += input_x_str;
+
+    const char *TENSOR_OUT_GRAD_TEMPLATE = " \n( out_grad , [%s]), ";
+    std::string input_out_grad_str =
+        paddle::string::Sprintf(TENSOR_OUT_GRAD_TEMPLATE, egr::EagerUtils::TensorStr(out_grad));
+    input_str += input_out_grad_str;
+
+    const char *TENSOR_OUTPUT_TEMPLATE = " \n ( returns , [%s]), ";
+    std::string output_returns_str = paddle::string::Sprintf(
+        TENSOR_OUTPUT_TEMPLATE, egr::EagerUtils::TensorStr(returns[0][0]));
+    output_str += output_returns_str;
+
+    VLOG(4) << paddle::string::Sprintf(INPUT_PRINT_TEMPLATE, input_str, output_str);
+    VLOG(6) << "gradnode_ptr = " << this << ", " << paddle::string::Sprintf(INPUT_PRINT_TEMPLATE, input_str, output_str);
+  }
+
   if (NeedComplexToRealConversion()) HandleComplexGradToRealGrad(&returns);
   return returns;
 }

paddle/fluid/eager/api/manual/eager_manual/nodes/conv2d_nodes.cc

@@ -162,6 +162,41 @@ Conv2dGradNodeFinal::operator()(
     // Set TensorWrappers for Forward Outputs if needed
   }
 
+    if (VLOG_IS_ON(4)) {
+    const char *INPUT_PRINT_TEMPLATE = "{ Input: [%s],  \n Output: [%s] } ";
+    std::string input_str = "";
+    std::string output_str = "";
+
+    const char *TENSOR_INPUT_TEMPLATE = " \n( input , [%s]), ";
+    std::string input_input_str =
+        paddle::string::Sprintf(TENSOR_INPUT_TEMPLATE, egr::EagerUtils::TensorStr(input));
+    input_str += input_input_str;
+
+    const char *TENSOR_FILTER_TEMPLATE = " \n( filter , [%s]), ";
+    std::string input_filter_str =
+        paddle::string::Sprintf(TENSOR_FILTER_TEMPLATE, egr::EagerUtils::TensorStr(filter));
+    input_str += input_filter_str;
+
+    const char *TENSOR_GRAD_OUT_TEMPLATE = " \n( grad_out , [%s]), ";
+    std::string input_grad_out_str =
+        paddle::string::Sprintf(TENSOR_GRAD_OUT_TEMPLATE, egr::EagerUtils::TensorStr(grad_out));
+    input_str += input_grad_out_str;
+
+    const char *TENSOR_GRAD_INPUT_TEMPLATE = " \n ( grad_input , [%s]), ";
+    std::string output_grad_input_str = paddle::string::Sprintf(
+        TENSOR_GRAD_INPUT_TEMPLATE, egr::EagerUtils::TensorStr(grad_input));
+    output_str += output_grad_input_str;
+
+    const char *TENSOR_GRAD_FILTER_TEMPLATE = " \n ( grad_filter , [%s]), ";
+    std::string output_grad_filter_str = paddle::string::Sprintf(
+        TENSOR_GRAD_FILTER_TEMPLATE, egr::EagerUtils::TensorStr(grad_filter));
+    output_str += output_grad_filter_str;
+
+    VLOG(4) << paddle::string::Sprintf(INPUT_PRINT_TEMPLATE, input_str, output_str);
+    VLOG(6) << "gradnode_ptr = " << this << ", " << paddle::string::Sprintf(INPUT_PRINT_TEMPLATE, input_str, output_str);
+  }
+
+
   // Return
   if (NeedComplexToRealConversion()) HandleComplexGradToRealGrad(&returns);
   return returns;
@@ -283,6 +318,57 @@ Conv2dDoubleGradNodeFinal::operator()(
 
   // Create Grad Node
 
+
+  if (VLOG_IS_ON(4)) {
+    const char *INPUT_PRINT_TEMPLATE = "{ Input: [%s],  \n Output: [%s] } ";
+    std::string input_str = "";
+    std::string output_str = "";
+
+    const char *TENSOR_INPUT_TEMPLATE = " \n( input , [%s]), ";
+    std::string input_input_str =
+        paddle::string::Sprintf(TENSOR_INPUT_TEMPLATE, egr::EagerUtils::TensorStr(input));
+    input_str += input_input_str;
+
+    const char *TENSOR_FILTER_TEMPLATE = " \n( filter , [%s]), ";
+    std::string input_filter_str =
+        paddle::string::Sprintf(TENSOR_FILTER_TEMPLATE, egr::EagerUtils::TensorStr(filter));
+    input_str += input_filter_str;
+
+    const char *TENSOR_GRAD_OUT_TEMPLATE = " \n( grad_out , [%s]), ";
+    std::string input_grad_out_str =
+        paddle::string::Sprintf(TENSOR_GRAD_OUT_TEMPLATE, egr::EagerUtils::TensorStr(grad_out));
+    input_str += input_grad_out_str;
+
+    const char *TENSOR_GRAD_INPUT_GRAD_TEMPLATE = " \n( grad_input_grad , [%s]), ";
+    std::string input_grad_input_grad_str =
+        paddle::string::Sprintf(TENSOR_GRAD_INPUT_GRAD_TEMPLATE, egr::EagerUtils::TensorStr(grad_input_grad));
+    input_str += input_grad_input_grad_str;
+
+    const char *TENSOR_GRAD_FILTER_GRAD_TEMPLATE = " \n( grad_filter_grad , [%s]), ";
+    std::string input_grad_filter_grad_str =
+        paddle::string::Sprintf(TENSOR_GRAD_FILTER_GRAD_TEMPLATE, egr::EagerUtils::TensorStr(grad_filter_grad));
+    input_str += input_grad_filter_grad_str;
+
+    const char *TENSOR_INPUT_GRAD_TEMPLATE = " \n( input_grad , [%s]), ";
+    std::string output_input_grad_str =
+        paddle::string::Sprintf(TENSOR_INPUT_GRAD_TEMPLATE, egr::EagerUtils::TensorStr(input_grad));
+    output_str += output_input_grad_str;
+
+    const char *TENSOR_FILTER_GRAD_TEMPLATE = " \n( filter_grad , [%s]), ";
+    std::string output_filter_grad_str =
+        paddle::string::Sprintf(TENSOR_FILTER_GRAD_TEMPLATE, egr::EagerUtils::TensorStr(filter_grad));
+    output_str += output_filter_grad_str;
+
+    const char *TENSOR_GRAD_OUT_GRAD_TEMPLATE = " \n( grad_out_grad , [%s]) ";
+    std::string output_grad_out_grad_str =
+        paddle::string::Sprintf(TENSOR_GRAD_OUT_GRAD_TEMPLATE, egr::EagerUtils::TensorStr(grad_out_grad));
+    output_str += output_grad_out_grad_str;
+
+    VLOG(4) << paddle::string::Sprintf(INPUT_PRINT_TEMPLATE, input_str, output_str);
+    VLOG(6) << "gradnode_ptr = " << this << ", " << paddle::string::Sprintf(INPUT_PRINT_TEMPLATE, input_str, output_str);
+  }
+
+
   // Return
   if (NeedComplexToRealConversion()) HandleComplexGradToRealGrad(&returns);
   return returns;

paddle/fluid/eager/api/manual/eager_manual/nodes/multiply_node.cc

@@ -596,6 +596,8 @@ MultiplyGradNode::operator()(
     output_str += output_y_grad_str;
     VLOG(4) << paddle::string::Sprintf(
         INPUT_PRINT_TEMPLATE, input_str, output_str);
+    VLOG(6) << "gradnode_ptr = " << this << ", " << paddle::string::Sprintf(
+        INPUT_PRINT_TEMPLATE, input_str, output_str);
   }
 
   // Return

paddle/fluid/eager/api/manual/eager_manual/nodes/sync_batch_norm_node.cc

@@ -459,6 +459,8 @@ SyncBatchNormGradNode::operator()(
     output_str += output_bias_grad_str;
     VLOG(4) << paddle::string::Sprintf(
         INPUT_PRINT_TEMPLATE, input_str, output_str);
+    VLOG(6) << "gradnode_ptr = " << this << ", " << paddle::string::Sprintf(
+    INPUT_PRINT_TEMPLATE, input_str, output_str);
   }
 
   // Return

paddle/fluid/eager/auto_code_generator/generator/eager_gen.py

@@ -176,6 +176,7 @@ class {} : public egr::GradNodeBase {{
 GRAD_FUNCTION_TEMPLATE = """
 paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize> {}::operator()(paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>& grads, bool create_graph, bool is_new_grad) {{
   VLOG(3) << \"Running AD API GRAD: \" << \"{}\";
+
   // Fill Zero For GradIn Tensors
 {}
   // Apply Gradient Hooks
@@ -204,7 +205,9 @@ class {} : public egr::GradNodeBase {{
   // Create Grad Node
 {}
   VLOG(4) << \"Finish AD API GRAD: {}";
+  VLOG(6) << "gradnode_ptr = " << this;
   // LOG IF DEBUG
+
   {}
   // Return
 {}
@@ -263,6 +266,7 @@ class {} : public egr::GradNodeBase {{
       const char* INPUT_PRINT_TEMPLATE = \"{{ Input: [%s],  \\n Output: [%s] }} \";
       {}
       VLOG(4) << paddle::string::Sprintf(INPUT_PRINT_TEMPLATE, input_str, output_str);
+      VLOG(6) << paddle::string::Sprintf(INPUT_PRINT_TEMPLATE, input_str, output_str);
   }}
 """
 

paddle/fluid/eager/grad_node_info.cc

@@ -575,4 +575,8 @@ std::vector<std::shared_ptr<GradNodeBase>> GradNodeBase::NextFunctions() {
   return next_nodes;
 }
 
+uintptr_t GradNodeBase::GetThisPtr() const {
+    return reinterpret_cast<uintptr_t>(this);
+}
+
 }  // namespace egr

paddle/fluid/eager/grad_node_info.h

@@ -253,6 +253,8 @@ class GradNodeBase {
 
   std::vector<std::shared_ptr<egr::GradNodeBase>> NextFunctions();
 
+  uintptr_t GetThisPtr() const;
+
   /**
    * Apply GradientHook
    * **/

paddle/fluid/eager/utils.h

@@ -255,7 +255,7 @@ class EagerUtils {
     }
     if (VLOG_IS_ON(11)) {
       const char* TENSOR_PRINT_TEMPLATE =
-          "{Name: %s, Initialized: %d, Ptr: %d "
+          "{Name: %s, Initialized: %d, Ptr: %d, "
           "TensorInfo: [ %s ], Value:[ %s ], ADInfo:[ %s ]}";
       auto* ad_meta = nullable_autograd_meta(t);
       if (ad_meta && (ad_meta->WeakGrad().lock().get())) {
@@ -306,7 +306,7 @@ class EagerUtils {
       }
     } else if (VLOG_IS_ON(6)) {
       const char* TENSOR_PRINT_TEMPLATE =
-          "{Name: %s, Initialized: %d, Ptr: %d "
+          "{Name: %s, Initialized: %d, Ptr: %d,"
           "TensorInfo: [ %s ], ADInfo:[ %s ]}";
       auto* ad_meta = nullable_autograd_meta(t);
       if (ad_meta && (ad_meta->WeakGrad().lock().get())) {
@@ -333,7 +333,7 @@ class EagerUtils {
       }
     } else if (VLOG_IS_ON(5)) {
       const char* TENSOR_PRINT_TEMPLATE =
-          "{Name: %s, Initialized: %d , Ptr: %d "
+          "{Name: %s, Initialized: %d , Ptr: %d, "
           "TensorInfo: [ %s ]}";
       return paddle::string::Sprintf(TENSOR_PRINT_TEMPLATE,
                                      tensor_name_str,

paddle/fluid/pybind/eager_properties.cc

@@ -318,17 +318,16 @@ PyObject* tensor_properties_get_grad_fn(TensorObject* self, void* closure) {
 
   if (meta) {
     // Get the GradNode from meta
-    auto grad_node = meta->GradNode();  // Convert GradNode to a Python object
-    // The conversion will depend on the structure of GradNode.
-
-    if (!grad_node) {
+    auto grad_node_ptr = meta->GetMutableGradNode();
+    if (!grad_node_ptr) {
       Py_INCREF(Py_None);
       return Py_None;
     }
 
-    PyObject* py_grad_node = ToPyObject(grad_node);
+    PyObject* py_grad_node = ToPyObject(grad_node_ptr);
 
     return py_grad_node;
+
   } else {
     // If meta does not exist, return an appropriate Python object (e.g., None
     // or a special value).

paddle/fluid/pybind/eager_utils.cc

@@ -1006,10 +1006,9 @@ paddle::optional<paddle::Tensor> GetOptionalTensorFromArgs(
   }
 }
 
-PyObject* ToPyObject(egr::GradNodeBase* grad_node) {
+PyObject* ToPyObject(std::shared_ptr<egr::GradNodeBase> grad_node) {
   py::object py_obj = py::cast(grad_node, py::return_value_policy::reference);
-  py::handle py_handle = py::handle(py_obj);
-  PyObject* py_grad_node = py_handle.ptr();
+  PyObject* py_grad_node = py_obj.release().ptr();
   Py_INCREF(py_grad_node);
   return py_grad_node;
 }

paddle/fluid/pybind/eager_utils.h

@@ -126,7 +126,7 @@ PyObject* ToPyObject(
     const std::unordered_map<std::string, std::vector<std::string>>& value);
 PyObject* ToPyObject(const paddle::framework::Vocab& value);
 
-PyObject* ToPyObject(egr::GradNodeBase* grad_node);
+PyObject* ToPyObject(std::shared_ptr<egr::GradNodeBase> grad_node);
 
 class PyTensorHook : public egr::TensorHook {
  public:

paddle/fluid/pybind/pybind.cc

@@ -778,12 +778,26 @@ PYBIND11_MODULE(libpaddle, m) {
           }
         });
 
-  py::class_<egr::GradNodeBase>(m, "GradNodeBase")
-      .def("name", &egr::GradNodeBase::name)
-      .def_property_readonly("next_functions",
-                             &egr::GradNodeBase::NextFunctions)
-      .def("input_meta", &egr::GradNodeBase::InputMeta)
-      .def("output_meta", &egr::GradNodeBase::OutputMeta);
+  py::class_<egr::GradNodeBase, std::shared_ptr<egr::GradNodeBase>>(
+      m, "GradNodeBase")
+      .def("name",
+           [](const std::shared_ptr<egr::GradNodeBase> &self) {
+             return self->name();
+           })
+      .def_property_readonly(
+          "next_functions",
+          [](const std::shared_ptr<egr::GradNodeBase> &self) {
+            return self->NextFunctions();
+          })
+
+      .def("node_this_ptr", &egr::GradNodeBase::GetThisPtr)
+      .def("input_meta",
+           [](const std::shared_ptr<egr::GradNodeBase> &self) {
+             return self->InputMeta();
+           })
+      .def("output_meta", [](const std::shared_ptr<egr::GradNodeBase> &self) {
+        return self->OutputMeta();
+      });
 
 #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
   m.def("cudnn_version", &platform::DnnVersion);

test/legacy_test/test_grad_fn_and_next_functions.py

@@ -83,6 +83,11 @@ def check_func(self, grad_fn, grad_fn_json) -> None:
             grad_fn_json (dict): grad_node_json of node
         """
         self.assertEqual(grad_fn.name(), grad_fn_json["func_name"])
+        # Recursively test other nodes
+        if hasattr(grad_fn, 'next_functions') and grad_fn.next_functions[0]:
+            next_funcs_json = grad_fn_json["next_funcs"]
+            for u in grad_fn.next_functions:
+                self.check_func(u, next_funcs_json[u.name()])
 
 
 if __name__ == "__main__":