Fixed CI issues

Author: jim19930609

paddle/fluid/eager/auto_code_generator/eager_generator.cc

@@ -577,11 +577,6 @@ static std::string GenerateGradNodeCreationContent(
  // If single output slotname and not duplicable,
  // then generate: "egr::AutogradMeta* p_autograd_out =
  // egr::EagerUtils::autograd_meta("op_proto->outputs()[0].name()")"
-
- // TODO(zhanlve): in case of multiple slotname but none of which are
- // duplicable,
- // avoid constructing vector<AutogradMeta*>, generate seperate
- // AutogradMeta* objects respectively.
  std::string get_autograd_meta_str = " // Prepare Autograd Meta \n";
  for (const proto::OpProto::Var& input : op_proto.inputs()) {
  const std::string& input_name = input.name();
@@ -607,11 +602,6 @@ static std::string GenerateGradNodeCreationContent(
  // If single output slotname and not duplicable,
  // then generate: "egr::AutogradMeta* p_autograd_out =
  // egr::EagerUtils::autograd_meta("op_proto.outputs()[0].name()")"
-
- // TODO(zhanlve): in case of multiple slotname but none of which are
- // duplicable,
- // avoid constructing vector<AutogradMeta*>, generate seperate
- // AutogradMeta* objects respectively.
  for (const proto::OpProto::Var& output : op_proto.outputs()) {
  const std::string& output_name = output.name();
  const std::string& output_autograd_name = "p_autograd_" + output_name;
@@ -725,9 +715,9 @@ static std::string GenerateGradNodeCreationContent(
  // [Generation] GradNode Creation
  const char* GRAD_NODE_CREATION_TEMPLATE =
  " %s"
- " bool require_any_grad = egr::ComputeRequireGrad(%s);\n"
+ " bool require_any_grad = egr::EagerUtils::ComputeRequireGrad(%s);\n"
  " if(require_any_grad) {\n"
- " egr::PassStopGradient(%s);\n"
+ " egr::EagerUtils::PassStopGradient(%s);\n"
  "%s\n }";
  std::string grad_node_creation_body_str = paddle::string::Sprintf(
  GRAD_NODE_CREATION_TEMPLATE, prepare_autograd_meta_str,
@@ -793,7 +783,7 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
  Controller.Instance().GetExpectedPlace(), {});
 
  // According to fwd_outputs_names
- std::vector<egr::EagerTensor> Out0 = GetOutputs(outs["Out0"]);
+ std::vector<egr::EagerTensor> Out0 = GGetOutputetOutputs(outs["Out0"]);
  egr::EagerTensor Out1 = GetOutputs(outs["Out1"][0]);
  std::vector<egr::EagerTensor> Out2 = GetOutputs(outs["Out2"]);
 
@@ -830,7 +820,8 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
  input_args_str_list[input_position] =
  paddle::string::Sprintf(FWD_INS_ARG_TEMPLATE, input_name);
  }
- const char* FWD_INS_CONTENT_TEMPLATE = "{ \"%s\", egr::SyncToVars(%s) },";
+ const char* FWD_INS_CONTENT_TEMPLATE =
+ "{ \"%s\", egr::EagerUtils::SyncToVars(%s) },";
  ins_contents_str += paddle::string::Sprintf(FWD_INS_CONTENT_TEMPLATE,
  input_name, input_name);
  }
@@ -925,14 +916,14 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
  if (output.duplicable()) {
  const char* FWD_OUT_TENSORS_TEMPLATE =
  " std::vector<egr::EagerTensor> %s = "
- "egr::GetOutputs(outs[\"%s\"]);\n";
+ "egr::EagerUtils::GetOutputs(outs[\"%s\"]);\n";
  out_tensor_str = paddle::string::Sprintf(FWD_OUT_TENSORS_TEMPLATE,
  output_name, output_name);
  return_types[return_position] = "std::vector<egr::EagerTensor>";
  } else {
  const char* FWD_OUT_TENSOR_TEMPLATE =
  " egr::EagerTensor %s = "
- "egr::GetOutput(outs[\"%s\"][0]);\n";
+ "egr::EagerUtils::GetOutput(outs[\"%s\"][0]);\n";
  out_tensor_str = paddle::string::Sprintf(FWD_OUT_TENSOR_TEMPLATE,
  output_name, output_name);
  return_types[return_position] = "egr::EagerTensor";
@@ -1093,7 +1084,8 @@ static std::string GenerateGradNodeCCContents(
  grad_ins_fwd_slotname_map.at(grad_input_name) + "_";
  const char* GRAD_INS_FWD_CONTENT_TEMPLATE =
  "{ \"%s\", "
- "egr::SyncToVars(egr::EagerUtils::RecoverTensorWrapper(&this->%s, "
+ "egr::EagerUtils::SyncToVars(egr::EagerUtils::RecoverTensorWrapper(&"
+ "this->%s, "
  "nullptr)) },";
  ins_contents_str +=
  paddle::string::Sprintf(GRAD_INS_FWD_CONTENT_TEMPLATE,
@@ -1104,7 +1096,7 @@ static std::string GenerateGradNodeCCContents(
  size_t fwd_output_position = fwd_outputs_name_pos_map.at(
  grad_ins_grad_slotname_map.at(grad_input_name));
  const char* GRAD_INS_GRAD_CONTENT_TEMPLATE =
- "{ \"%s\", egr::SyncToVars(grads[%d]) },";
+ "{ \"%s\", egr::EagerUtils::SyncToVars(grads[%d]) },";
  ins_contents_str += paddle::string::Sprintf(
  GRAD_INS_GRAD_CONTENT_TEMPLATE, grad_input_name, fwd_output_position);
 
@@ -1206,7 +1198,7 @@ static std::string GenerateGradNodeCCContents(
  fwd_inputs_name_pos_map.at(grad_outs_slotname_map.at(grad_out_name));
 
  const char* BWD_OUTPUT_TEMPLATE =
- " outputs[%d] = GetOutputs(outs[\"%s\"]);\n";
+ " outputs[%d] = egr::EagerUtils::GetOutputs(outs[\"%s\"]);\n";
  outputs_str += paddle::string::Sprintf(BWD_OUTPUT_TEMPLATE,
  fwd_input_position, grad_out_name);
  }
@@ -1526,6 +1518,9 @@ static void DygraphCodeGeneration(const std::string& output_dir) {
  GenerateForwardHFile(output_dir, dygraph_forward_api_str);
 }
 
+} // namespace framework
+} // namespace paddle
+
 int main(int argc, char* argv[]) {
  if (argc != 2) {
  std::cerr << "argc must be 2" << std::endl;
@@ -1537,6 +1532,3 @@ int main(int argc, char* argv[]) {
 
  return 0;
 }
-
-} // namespace framework
-} // namespace paddle

paddle/fluid/eager/legacy/prepared_operator.cc

@@ -20,7 +20,7 @@
 #include "paddle/fluid/framework/pten_utils.h"
 #include "paddle/utils/small_vector.h"
 #ifdef PADDLE_WITH_XPU
-#include "paddle/fluid/platform/xpu/xpu_op_list.h"
+#include "paddle/fluid/platform/device/xpu/xpu_op_list.h"
 #endif
 DECLARE_bool(check_nan_inf);
 DECLARE_bool(run_pten_kernel);

paddle/fluid/eager/tests/task_tests/generated_test.cc

@@ -19,6 +19,7 @@
 #include "gtest/gtest.h"
 
 #include "paddle/fluid/eager/api/all.h"
+#include "paddle/fluid/eager/api/utils/tensor_utils.h"
 #include "paddle/fluid/eager/autograd_meta.h"
 #include "paddle/fluid/eager/backward.h"
 #include "paddle/fluid/eager/utils.h"
@@ -29,23 +30,19 @@
 #include "paddle/fluid/eager/api/generated/fluid_generated/dygraph_forward_api.h"
 #include "paddle/pten/core/kernel_registry.h"
 
-PT_DECLARE_MODULE(CreationCPU);
-
-#if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
-PT_DECLARE_MODULE(CreationCUDA);
-#endif
-
 // TODO(jiabin): remove nolint here!!!
 using namespace egr; // NOLINT
 
+namespace eager_test {
+
 TEST(Generated, Sigmoid) {
  // Prepare Device Contexts
  InitEnv(paddle::platform::CPUPlace());
  VLOG(6) << "Init Env";
  // 1. Prepare Input
  paddle::framework::DDim ddim = paddle::framework::make_ddim({2, 4, 4, 4});
  VLOG(6) << "Make Dim";
- egr::EagerTensor tensor = EagerUtils::CreateTensorWithValue(
+ egr::EagerTensor tensor = CreateTensorWithValue(
  ddim, paddle::platform::CPUPlace(), pten::DataType::FLOAT32,
  pten::DataLayout::NCHW, 0.0, true);
  VLOG(6) << "Make EagerTensor";
@@ -72,13 +69,13 @@ TEST(Generated, Matmul_v2) {
 
  // 1. Prepare Input
  paddle::framework::DDim ddimX = paddle::framework::make_ddim({4, 16});
- egr::EagerTensor X = EagerUtils::CreateTensorWithValue(
+ egr::EagerTensor X = CreateTensorWithValue(
  ddimX, paddle::platform::CPUPlace(), pten::DataType::FLOAT32,
  pten::DataLayout::NCHW, 3.0, true);
  RetainGradForTensor(X);
 
  paddle::framework::DDim ddimY = paddle::framework::make_ddim({16, 20});
- egr::EagerTensor Y = EagerUtils::CreateTensorWithValue(
+ egr::EagerTensor Y = CreateTensorWithValue(
  ddimY, paddle::platform::CPUPlace(), pten::DataType::FLOAT32,
  pten::DataLayout::NCHW, 2.0, true);
  RetainGradForTensor(Y);
@@ -94,3 +91,5 @@ TEST(Generated, Matmul_v2) {
  CompareGradVariableWithValue<float>(X, 2.0 * 20);
  CompareGradVariableWithValue<float>(Y, 3.0 * 4);
 }
+
+} // namespace eager_test

paddle/fluid/eager/utils.cc

@@ -14,6 +14,7 @@
 
 #include "paddle/fluid/eager/utils.h"
 #include "paddle/fluid/eager/api/utils/global_utils.h"
+#include "paddle/fluid/eager/tensor_wrapper.h"
 
 #include "paddle/pten/api/all.h"
 #include "paddle/pten/common/layout.h"
@@ -188,4 +189,19 @@ egr::EagerTensor EagerUtils::GetOutput(
  return EagerTensor((*(out.get())));
 }
 
+EagerTensor EagerUtils::RecoverTensorWrapper(
+ TensorWrapper* tw, const std::shared_ptr<GradNodeBase>& grad_node) {
+ return tw->recover(grad_node);
+}
+
+std::vector<EagerTensor> EagerUtils::RecoverTensorWrapper(
+ std::vector<TensorWrapper>* tw,
+ const std::shared_ptr<GradNodeBase>& grad_node) {
+ std::vector<EagerTensor> ret;
+ for (auto& t : *tw) {
+ ret.emplace_back(t.recover(grad_node));
+ }
+ return ret;
+}
+
 } // namespace egr

paddle/fluid/eager/utils.h

@@ -22,6 +22,8 @@
 
 namespace egr {
 
+class TensorWrapper;
+
 /**
  * EagerUtils is utils used to do some static conversion or autograd
  * members access, this class is desinged to be a full static functional
@@ -131,6 +133,13 @@ class EagerUtils {
  iter.apply(std::forward<Args>(args)...);
  }
 
+ // TensorWrapper Utils
+ static egr::EagerTensor RecoverTensorWrapper(
+ egr::TensorWrapper* tw, const std::shared_ptr<GradNodeBase>& grad_node);
+ static std::vector<egr::EagerTensor> RecoverTensorWrapper(
+ std::vector<egr::TensorWrapper>* tw,
+ const std::shared_ptr<GradNodeBase>& grad_node);
+
  // Intermidate needed remove this once we don't need legacy
  static std::vector<std::shared_ptr<egr::EagerTensor>> SyncToVars(
  const egr::EagerTensor& tensor);

paddle/fluid/framework/details/nan_inf_utils.h

@@ -17,6 +17,7 @@
 #include <string>
 #include <vector>
 
+#include "paddle/fluid/eager/legacy/type_def.h"
 #include "paddle/fluid/framework/operator.h"
 #include "paddle/fluid/framework/scope.h"
 #include "paddle/fluid/imperative/type_defs.h"
@@ -53,6 +54,19 @@ void CheckOpHasNanOrInfInDygraph(const std::string& op_type,
  }
 }
 
+template <typename TensorType>
+static void CheckOpHasNanOrInfInEager(const std::string& op_type,
+ const egr::NameMap<TensorType>& op_outs,
+ platform::Place place) {
+ for (const auto& pair : op_outs) {
+ for (const auto& tensor : pair.second) {
+ auto* var = tensor->MutableVar();
+ if (var == nullptr) continue;
+ CheckVarHasNanOrInf(op_type, tensor->name(), var, place);
+ }
+ }
+}
+
 #ifdef PADDLE_WITH_ASCEND_CL
 void NPUAllocAndClearFloatStatus(const framework::OperatorBase& op,
  const framework::ScopeBase& scope,