Refactored trace_op logic for eager mode

Author: jim19930609

paddle/fluid/eager/auto_code_generator/eager_generator.cc

@@ -34,6 +34,8 @@ std::unordered_map<std::string, std::vector<std::string>>
  core_ops_returns_info = {};
 std::unordered_map<std::string, std::vector<std::string>> core_ops_args_info =
  {};
+std::unordered_map<std::string, std::vector<std::string>>
+ core_ops_args_type_info = {};
 
 /* --- Static maps to handle corner cases --- */
 static std::unordered_map<std::string, paddle::framework::AttributeMap>
@@ -1120,7 +1122,9 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
  std::string generated_function_body = "";
  std::string dygraph_function_args_str = "";
  core_ops_args_info[op_type] = {};
+ core_ops_args_type_info[op_type] = {};
  core_ops_args_info[op_type].resize(in_vars.size());
+ core_ops_args_type_info[op_type].resize(in_vars.size());
 
  /* ------ Dygraph forward function generation ------ */
  generated_function_body += " // Dygraph Forward Pass\n";
@@ -1138,10 +1142,14 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
  "const std::vector<egr::EagerTensor>& %s";
  input_args_str_list[input_position] =
  paddle::string::Sprintf(FWD_INS_ARG_TEMPLATE, input_name);
+
+ core_ops_args_type_info[op_type][input_position] = "list";
  } else {
  const char* FWD_INS_ARG_TEMPLATE = "const egr::EagerTensor& %s";
  input_args_str_list[input_position] =
  paddle::string::Sprintf(FWD_INS_ARG_TEMPLATE, input_name);
+
+ core_ops_args_type_info[op_type][input_position] = "tensor";
  }
  core_ops_args_info[op_type][input_position] = input_name;
 
@@ -1210,11 +1218,14 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
  paddle::string::Sprintf(FWD_NUM_ARG_TEMPLATE, output_var_name);
  dygraph_function_args_str += arg_str;
 
+ core_ops_args_type_info[op_type].push_back("list");
  } else {
  const char* FWD_NUM_ARG_TEMPLATE = ", egr::EagerTensor* %s";
  std::string arg_str =
  paddle::string::Sprintf(FWD_NUM_ARG_TEMPLATE, output_var_name);
  dygraph_function_args_str += arg_str;
+
+ core_ops_args_type_info[op_type].push_back("tensor");
  }
  const char* FWD_OUTS_CONTENT_TEMPLATE =
  "{ \"%s\", egr::EagerUtils::TrySyncToVars(%s) },";
@@ -1236,6 +1247,7 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
  outs_contents_str += paddle::string::Sprintf(FWD_OUTS_CONTENT_TEMPLATE,
  output_name, outnum);
  core_ops_args_info[op_type].push_back(outnum);
+ core_ops_args_type_info[op_type].push_back("int");
  } else {
  const char* FWD_OUTS_CONTENT_TEMPLATE =
  "{ \"%s\", "
@@ -1840,6 +1852,9 @@ static std::string GenerateDygraphHFileIncludes() {
  dygraph_forward_api_includes_str +=
  "extern std::unordered_map<std::string, std::vector<std::string>> "
  "core_ops_args_info;\n";
+ dygraph_forward_api_includes_str +=
+ "extern std::unordered_map<std::string, std::vector<std::string>> "
+ "core_ops_args_type_info;\n";
  dygraph_forward_api_includes_str +=
  "extern std::unordered_map<std::string, std::vector<std::string>> "
  "core_ops_returns_info;\n\n";
@@ -1936,16 +1951,20 @@ static std::string GenerateCoreOpsReturnsInfo() {
  "std::unordered_map<std::string, std::vector<std::string>> "
  "core_ops_args_info = { %s };\n"
  "std::unordered_map<std::string, std::vector<std::string>> "
+ "core_ops_args_type_info = { %s };\n"
+ "std::unordered_map<std::string, std::vector<std::string>> "
  "core_ops_returns_info = { %s };\n";
 
  std::string core_ops_args_info_init_str =
  ConvertCoreOpsInfosToString(core_ops_args_info);
+ std::string core_ops_args_type_info_init_str =
+ ConvertCoreOpsInfosToString(core_ops_args_type_info);
  std::string core_ops_returns_info_init_str =
  ConvertCoreOpsInfosToString(core_ops_returns_info);
 
  std::string core_ops_info_str = paddle::string::Sprintf(
  Core_Ops_Returns_MAP_TEMPLATE, core_ops_args_info_init_str,
- core_ops_returns_info_init_str);
+ core_ops_args_type_info_init_str, core_ops_returns_info_init_str);
 
  return core_ops_info_str;
 }

paddle/fluid/framework/variable.h

@@ -64,8 +64,10 @@ class Variable {
  void Clear() { holder_.reset(); }
 
  int Type() const {
+ VLOG(1) << 11111;
  PADDLE_ENFORCE_NOT_NULL(
  holder_, platform::errors::NotFound("Variable is not initialized."));
+ VLOG(1) << (holder_ == nullptr);
  return holder_->Type();
  }
 

paddle/fluid/pybind/eager_op_function_generator.cc

@@ -313,6 +313,21 @@ static std::string GenerateCoreOpsInfoMap() {
  " }\n"
  "}\n"
  "\n"
+ "static PyObject * eager_get_core_ops_args_type_info(PyObject *self) {\n"
+ " PyThreadState *tstate = nullptr;\n"
+ " try\n"
+ " {\n"
+ " return ToPyObject(core_ops_args_type_info);\n"
+ " }\n"
+ " catch(...) {\n"
+ " if (tstate) {\n"
+ " PyEval_RestoreThread(tstate);\n"
+ " }\n"
+ " ThrowExceptionToPython(std::current_exception());\n"
+ " return nullptr;\n"
+ " }\n"
+ "}\n"
+ "\n"
  "static PyObject * eager_get_core_ops_returns_info(PyObject *self) {\n"
  " PyThreadState *tstate = nullptr;\n"
  " try\n"
@@ -399,6 +414,10 @@ int main(int argc, char* argv[]) {
  "{\"get_core_ops_args_info\", "
  "(PyCFunction)(void(*)(void))eager_get_core_ops_args_info, METH_NOARGS, "
  "\"C++ interface function for eager_get_core_ops_args_info.\"},\n"
+ "{\"get_core_ops_args_type_info\", "
+ "(PyCFunction)(void(*)(void))eager_get_core_ops_args_type_info, "
+ "METH_NOARGS, "
+ "\"C++ interface function for eager_get_core_ops_args_type_info.\"},\n"
  " {\"get_core_ops_returns_info\", "
  "(PyCFunction)(void(*)(void))eager_get_core_ops_returns_info, "
  "METH_NOARGS, \"C++ interface function for "

python/paddle/fluid/dygraph/tracer.py

@@ -48,36 +48,68 @@ def trace_op(self,
  stop_gradient=False,
  inplace_map=None):
  if framework._in_eager_mode():
+ # inputs : {"sum": [tensor], ...}
+ # outputs : {"sum": [tensor], ...}
+
  function_ptr = _C_ops.__dict__[type]
 
  core_ops_args_info = _C_ops.get_core_ops_args_info()
+ core_ops_args_type_info = _C_ops.get_core_ops_args_type_info()
  core_ops_returns_info = _C_ops.get_core_ops_returns_info()
 
  op_args = core_ops_args_info[type]
+ op_args_type = core_ops_args_type_info[type]
  op_returns = core_ops_returns_info[type]
 
  arg_list = []
- for arg in op_args:
- if arg in inputs.keys():
- arg_list.append(inputs[arg])
- elif arg in outputs.keys():
- arg_list.append(outputs[arg])
+ for i in range(len(op_args)):
+ arg_name = op_args[i]
+ arg_type = op_args_type[i]
+ if arg_name in inputs.keys():
+ arg_to_append = inputs[arg_name]
+ elif arg_name in outputs.keys():
+ arg_to_append = outputs[arg_name]
  else:
- if "Num" in arg:
+ if "Num" in arg_name:
  # Remove "Num" suffix to get out_name
- out_name = arg[:-3]
+ out_name = arg_name[:-3]
  assert out_name in outputs.keys()
  num_outs = len(outputs[out_name])
- arg_list.append(num_outs)
+ arg_to_append = num_outs
  else:
- arg_list.append(None)
- returns = function_ptr(*arg_list, **attrs)
-
- for i in range(len(op_returns)):
- retname = op_returns[i]
- if retname in outputs.keys():
- # Replaced outputs by function returns
- outputs[retname] = returns[i]
+ arg_to_append = None
+
+ if arg_to_append is None:
+ arg_list.append(arg_to_append)
+ elif arg_type == "tensor":
+ arg_list.append(arg_to_append[0])
+ elif arg_type == "list":
+ arg_list.append(arg_to_append)
+ elif arg_type == "int":
+ arg_list.append(arg_to_append)
+ else:
+ assert False
+
+ attrs_list = []
+ for k, v in attrs.items():
+ attrs_list.append(k)
+ attrs_list.append(v)
+ returns = function_ptr(*arg_list, *attrs_list)
+
+ if isinstance(returns, tuple):
+ for i in range(len(op_returns)):
+ retname = op_returns[i]
+ if retname in outputs.keys():
+ # Replaced outputs by function returns
+ outputs[retname] = returns[i]
+ elif isinstance(returns, list):
+ assert len(outputs.keys()) == 1
+ key = list(outputs.keys())[0]
+ outputs[key] = returns
+ else:
+ assert len(outputs.keys()) == 1
+ key = list(outputs.keys())[0]
+ outputs[key] = [returns]
  else:
  self.trace(type, inputs, outputs, attrs,
  framework._current_expected_place(), self._has_grad and

python/paddle/fluid/tests/unittests/op_test.py

@@ -25,6 +25,7 @@
 import itertools
 import collections
 from collections import defaultdict
+from copy import copy
 
 import paddle
 import paddle.fluid as fluid
@@ -491,7 +492,7 @@ def _append_ops(self, block):
  type=self.op_type,
  inputs=inputs,
  outputs=outputs,
- attrs=self.attrs if hasattr(self, "attrs") else dict())
+ attrs=copy(self.attrs) if hasattr(self, "attrs") else dict())
  # infer variable type and infer shape in compile-time
  op.desc.infer_var_type(block.desc)
  op.desc.infer_shape(block.desc)
@@ -1172,8 +1173,7 @@ def find_actual(target_name, fetch_list):
  if check_dygraph:
  imperative_actual = find_imperative_actual(
  sub_out_name, dygraph_outs, place)
- imperative_actual_t = np.array(imperative_actual.value()
- .get_tensor())
+ imperative_actual_t = imperative_actual.numpy()
  idx = find_actual(sub_out_name, fetch_list)
  actual = outs[idx]
  actual_t = np.array(actual)
@@ -1209,8 +1209,7 @@ def find_actual(target_name, fetch_list):
  if check_dygraph:
  imperative_actual = find_imperative_actual(
  out_name, dygraph_outs, place)
- imperative_actual_t = np.array(imperative_actual.value()
- .get_tensor())
+ imperative_actual_t = imperative_actual.numpy()
  idx = find_actual(out_name, fetch_list)
  actual = outs[idx]
  actual_t = np.array(actual)