deal with conflict

Author: YuanRisheng

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

@@ -724,10 +724,11 @@ def GenerateNodeCreationCodes(self):
  is_optional = (name in optional_inputs)
 
  if is_fwd_input:
+ need_input_data = "false" if name in self.no_need_buffers else "true"
  if is_optional:
  set_tensor_wrappers = f"{indent}if({name}.get_ptr() != nullptr) grad_node->SetTensorWrapper{name}(*({name}.get_ptr()), true);"
  else:
- set_tensor_wrappers = f"{indent}grad_node->SetTensorWrapper{name}({name}, true);"
+ set_tensor_wrappers = f"{indent}grad_node->SetTensorWrapper{name}({name}, {need_input_data});"
  else:
  if num_fwd_outputs > 1:
  # Aligned with forward output position

paddle/fluid/eager/tensor_wrapper.h

@@ -51,14 +51,14 @@ class TensorWrapper {
  * to avoid recursive depends on GradNodeBase
  * **/
  full_reserved_ = full_reserved;
+ no_need_buffer_ = no_need_buffer;
  if (full_reserved_) {
  VLOG(6) << "Fully reserved tensor: " << tensor.name();
  intermidiate_tensor_ = tensor;
  return;
  }
 
  // shallow copy tensor_impl here
- no_need_buffer_ = no_need_buffer;
  if (no_need_buffer) {
  if (phi::DenseTensor::classof(tensor.impl().get())) {
  // Only Copy Meta

paddle/fluid/pybind/eager.cc

@@ -78,6 +78,10 @@ void EmptyTensorInitializer(TensorObject* self, const std::string& name,
  phi::DenseTensorMeta(paddle::framework::TransToPhiDataType(dtype),
  ddims));
  self->tensor.set_impl(dense_tensor);
+ } else if (var_type == paddle::framework::proto::VarType::SELECTED_ROWS) {
+ std::shared_ptr<phi::SelectedRows> tensor =
+ std::make_shared<phi::SelectedRows>();
+ self->tensor.set_impl(tensor);
  }
 
  if (!autograd_meta->GetMutableGradNode()) {

paddle/fluid/pybind/eager_method.cc

@@ -465,6 +465,9 @@ static PyObject* tensor__share_buffer_to(TensorObject* self, PyObject* args,
  self->tensor.name()));
  auto* src_tensor =
  static_cast<paddle::framework::Tensor*>(self->tensor.impl().get());
+ if (!dst_ptr->defined()) {
+ dst_ptr->set_impl(std::make_shared<phi::DenseTensor>());
+ }
  auto dst_tensor =
  static_cast<paddle::framework::Tensor*>(dst_ptr->impl().get());
  dst_tensor->ShareDataWith(*src_tensor);
@@ -565,6 +568,10 @@ static PyObject* tensor_method_get_underline_tensor(TensorObject* self,
  PyObject* args,
  PyObject* kwargs) {
  EAGER_TRY
+ if (!self->tensor.defined()) {
+ Py_IncRef(Py_None);
+ return Py_None;
+ }
  if (self->tensor.is_dense_tensor()) {
  auto* tensor =
  static_cast<paddle::framework::LoDTensor*>(self->tensor.impl().get());
@@ -577,6 +584,25 @@ static PyObject* tensor_method_get_underline_tensor(TensorObject* self,
  EAGER_CATCH_AND_THROW_RETURN_NULL
 }
 
+static PyObject* tensor_method_get_underline_selected_rows(TensorObject* self,
+ PyObject* args,
+ PyObject* kwargs) {
+ EAGER_TRY
+ if (!self->tensor.defined()) {
+ Py_IncRef(Py_None);
+ return Py_None;
+ }
+ if (self->tensor.is_selected_rows()) {
+ auto* selected_rows =
+ static_cast<phi::SelectedRows*>(self->tensor.impl().get());
+ return ToPyObject(selected_rows);
+ } else {
+ Py_IncRef(Py_None);
+ return Py_None;
+ }
+ EAGER_CATCH_AND_THROW_RETURN_NULL
+}
+
 static PyObject* tensor__getitem_index_not_tensor(TensorObject* self,
  PyObject* args,
  PyObject* kwargs) {
@@ -1214,6 +1240,9 @@ static PyObject* tensor_method_get_non_zero_cols(TensorObject* self,
 static PyObject* tensor_method_is_sparse(TensorObject* self, PyObject* args,
  PyObject* kwargs) {
  EAGER_TRY
+ if (!self->tensor.defined()) {
+ return ToPyObject(false);
+ }
  return ToPyObject(self->tensor.is_sparse_coo_tensor() ||
  self->tensor.is_sparse_csr_tensor());
  EAGER_CATCH_AND_THROW_RETURN_NULL
@@ -1222,13 +1251,19 @@ static PyObject* tensor_method_is_sparse(TensorObject* self, PyObject* args,
 static PyObject* tensor_method_is_sparse_coo(TensorObject* self, PyObject* args,
  PyObject* kwargs) {
  EAGER_TRY
+ if (!self->tensor.defined()) {
+ return ToPyObject(false);
+ }
  return ToPyObject(self->tensor.is_sparse_coo_tensor());
  EAGER_CATCH_AND_THROW_RETURN_NULL
 }
 
 static PyObject* tensor_method_is_sparse_csr(TensorObject* self, PyObject* args,
  PyObject* kwargs) {
  EAGER_TRY
+ if (!self->tensor.defined()) {
+ return ToPyObject(false);
+ }
  return ToPyObject(self->tensor.is_sparse_csr_tensor());
  EAGER_CATCH_AND_THROW_RETURN_NULL
 }
@@ -1307,6 +1342,9 @@ static PyObject* tensor_method_is_selected_rows(TensorObject* self,
  PyObject* args,
  PyObject* kwargs) {
  EAGER_TRY
+ if (!self->tensor.defined()) {
+ return ToPyObject(false);
+ }
  return ToPyObject(self->tensor.is_selected_rows());
  EAGER_CATCH_AND_THROW_RETURN_NULL
 }
@@ -1323,6 +1361,13 @@ static PyObject* tensor_method_get_rows(TensorObject* self, PyObject* args,
  EAGER_CATCH_AND_THROW_RETURN_NULL
 }
 
+static PyObject* tensor_methon_element_size(TensorObject* self, PyObject* args,
+ PyObject* kwargs) {
+ EAGER_TRY
+ return ToPyObject(paddle::experimental::SizeOf(self->tensor.dtype()));
+ EAGER_CATCH_AND_THROW_RETURN_NULL
+}
+
 static PyObject* tensor__reset_grad_inplace_version(TensorObject* self,
  PyObject* args,
  PyObject* kwargs) {
@@ -1420,6 +1465,9 @@ PyMethodDef variable_methods[] = {
  {"get_tensor",
  (PyCFunction)(void (*)(void))tensor_method_get_underline_tensor,
  METH_VARARGS | METH_KEYWORDS, NULL},
+ {"get_selected_rows",
+ (PyCFunction)(void (*)(void))tensor_method_get_underline_selected_rows,
+ METH_VARARGS | METH_KEYWORDS, NULL},
  {"_getitem_index_not_tensor",
  (PyCFunction)(void (*)(void))tensor__getitem_index_not_tensor,
  METH_VARARGS | METH_KEYWORDS, NULL},
@@ -1482,6 +1530,8 @@ PyMethodDef variable_methods[] = {
  METH_VARARGS | METH_KEYWORDS, NULL},
  {"rows", (PyCFunction)(void (*)(void))tensor_method_get_rows,
  METH_VARARGS | METH_KEYWORDS, NULL},
+ {"element_size", (PyCFunction)(void (*)(void))tensor_methon_element_size,
+ METH_VARARGS | METH_KEYWORDS, NULL},
  {"_reset_grad_inplace_version",
  (PyCFunction)(void (*)(void))tensor__reset_grad_inplace_version,
  METH_VARARGS | METH_KEYWORDS, NULL},

paddle/fluid/pybind/eager_properties.cc

@@ -43,8 +43,14 @@ PyObject* tensor_properties_get_name(TensorObject* self, void* closure) {
 
 PyObject* tensor_properties_get_type(TensorObject* self, void* closure) {
  EAGER_TRY
+ if (!self->tensor.defined()) {
+ // be same to old dygraph
+ return ToPyObject(paddle::framework::proto::VarType::LOD_TENSOR);
+ }
  if (self->tensor.is_dense_tensor()) {
  return ToPyObject(paddle::framework::proto::VarType::LOD_TENSOR);
+ } else if (self->tensor.is_selected_rows()) {
+ return ToPyObject(paddle::framework::proto::VarType::SELECTED_ROWS);
  } else {
  Py_INCREF(Py_None);
  return Py_None;
@@ -137,8 +143,11 @@ int tensor_properties_set_persistable(TensorObject* self, PyObject* value,
 
 PyObject* tensor_properties_get_shape(TensorObject* self, void* closure) {
  EAGER_TRY
- auto ddim = self->tensor.shape();
  std::vector<int64_t> value;
+ if (!self->tensor.defined()) {
+ return ToPyObject(value);
+ }
+ auto ddim = self->tensor.shape();
  size_t rank = static_cast<size_t>(ddim.size());
  value.resize(rank);
  for (size_t i = 0; i < rank; i++) {
@@ -165,6 +174,10 @@ PyObject* tensor_properties_get_place_str(TensorObject* self, void* closure) {
 
 PyObject* tensor_properties_get_dtype(TensorObject* self, void* closure) {
  EAGER_TRY
+ if (!self->tensor.defined()) {
+ // be same to old dygraph
+ return ToPyObject(framework::proto::VarType::FP32);
+ }
  return ToPyObject(
  paddle::framework::TransToProtoVarType(self->tensor.type()));
  EAGER_CATCH_AND_THROW_RETURN_NULL

paddle/fluid/pybind/eager_utils.cc

@@ -577,6 +577,12 @@ PyObject* ToPyObject(const paddle::framework::LoDTensor* value) {
  return obj.ptr();
 }
 
+PyObject* ToPyObject(const phi::SelectedRows* value) {
+ auto obj = ::pybind11::cast(value, py::return_value_policy::reference);
+ obj.inc_ref();
+ return obj.ptr();
+}
+
 PyObject* ToPyObject(const void* value) {
  if (value == nullptr) {
  Py_INCREF(Py_None);

paddle/fluid/pybind/eager_utils.h

@@ -75,6 +75,7 @@ PyObject* ToPyObject(const std::vector<paddle::experimental::Tensor>& value,
  bool return_py_none_if_not_initialize = false);
 PyObject* ToPyObject(const platform::Place& value);
 PyObject* ToPyObject(const framework::LoDTensor* value);
+PyObject* ToPyObject(const phi::SelectedRows* value);
 PyObject* ToPyObject(const paddle::framework::proto::VarType::Type& dtype);
 PyObject* ToPyObject(const paddle::framework::proto::VarType& type);
 PyObject* ToPyObject(const void* value);

paddle/phi/api/lib/api_custom_impl.cc

@@ -32,51 +32,7 @@ limitations under the License. */
 namespace paddle {
 namespace experimental {
 
-// TODO(chenweihang): the original sum grad op can support higher-level
-// differentiation,
-// but if we use this impl, it will not support. We need to be able to reuse
-// the autograd API here, which is not yet implemented
-// TODO(chenweihang): we should support call generated api in custom api impl
-std::vector<Tensor> add_n_grad_impl(const std::vector<Tensor>& x,
- const Tensor& out_grad) {
- auto kernel_key_set = ParseKernelKeyByInputArgs(out_grad);
- auto kernel_key = kernel_key_set.GetHighestPriorityKernelKey();
-
- Backend kernel_backend = kernel_key.backend();
- DataLayout kernel_layout = kernel_key.layout();
- DataType kernel_data_type = kernel_key.dtype();
-
- auto kernel = phi::KernelFactory::Instance().SelectKernelOrThrowError(
- "scale", {kernel_backend, kernel_layout, kernel_data_type});
- VLOG(6) << "add_n_grad API kernel key: [" << kernel_backend << ", "
- << kernel_layout << ", " << kernel_data_type << "]";
- VLOG(6) << "add_n_grad API kernel: " << kernel;
-
- auto* dev_ctx = GetDeviceContextByBackend(kernel_backend);
-
- auto dense_out_grad = PrepareData(out_grad, kernel.InputAt(0), {});
-
- size_t out_number = x.size();
- std::vector<Tensor> x_grad;
- auto dense_x_grad = SetKernelOutput(out_number, kernel_backend, &x_grad);
-
- using kernel_signature = void (*)(const platform::DeviceContext&,
- const phi::DenseTensor&,
- const phi::Scalar&,
- float,
- bool,
- phi::DenseTensor*);
- auto* kernel_fn = kernel.GetVariadicKernelFn<kernel_signature>();
-
- for (auto* dense_x_grad_t : dense_x_grad) {
- phi::MetaTensor meta_out(dense_x_grad_t);
- phi::UnchangedInferMeta(MakeMetaTensor(*dense_out_grad), &meta_out);
- (*kernel_fn)(
- *dev_ctx, *dense_out_grad, phi::Scalar(1.0), 0.0, true, dense_x_grad_t);
- }
-
- return x_grad;
-}
+////////////////// Forward api impls //////////////////////
 
 Tensor copy_to_impl(const Tensor& x, Place place, bool blocking) {
  auto kernel_key_set = ParseKernelKeyByInputArgs(x);
@@ -310,6 +266,54 @@ std::tuple<Tensor, Tensor, Tensor> momentum_impl(
  return api_output;
 }
 
+////////////////// Backward(grad) api impls //////////////////////
+
+// TODO(chenweihang): the original sum grad op can support higher-level
+// differentiation,
+// but if we use this impl, it will not support. We need to be able to reuse
+// the autograd API here, which is not yet implemented
+// TODO(chenweihang): we should support call generated api in custom api impl
+std::vector<Tensor> add_n_grad_impl(const std::vector<Tensor>& x,
+ const Tensor& out_grad) {
+ auto kernel_key_set = ParseKernelKeyByInputArgs(out_grad);
+ auto kernel_key = kernel_key_set.GetHighestPriorityKernelKey();
+
+ Backend kernel_backend = kernel_key.backend();
+ DataLayout kernel_layout = kernel_key.layout();
+ DataType kernel_data_type = kernel_key.dtype();
+
+ auto kernel = phi::KernelFactory::Instance().SelectKernelOrThrowError(
+ "scale", {kernel_backend, kernel_layout, kernel_data_type});
+ VLOG(6) << "add_n_grad API kernel key: [" << kernel_backend << ", "
+ << kernel_layout << ", " << kernel_data_type << "]";
+ VLOG(6) << "add_n_grad API kernel: " << kernel;
+
+ auto* dev_ctx = GetDeviceContextByBackend(kernel_backend);
+
+ auto dense_out_grad = PrepareData(out_grad, kernel.InputAt(0), {});
+
+ size_t out_number = x.size();
+ std::vector<Tensor> x_grad;
+ auto dense_x_grad = SetKernelOutput(out_number, kernel_backend, &x_grad);
+
+ using kernel_signature = void (*)(const platform::DeviceContext&,
+ const phi::DenseTensor&,
+ const phi::Scalar&,
+ float,
+ bool,
+ phi::DenseTensor*);
+ auto* kernel_fn = kernel.GetVariadicKernelFn<kernel_signature>();
+
+ for (auto* dense_x_grad_t : dense_x_grad) {
+ phi::MetaTensor meta_out(dense_x_grad_t);
+ phi::UnchangedInferMeta(MakeMetaTensor(*dense_out_grad), &meta_out);
+ (*kernel_fn)(
+ *dev_ctx, *dense_out_grad, phi::Scalar(1.0), 0.0, true, dense_x_grad_t);
+ }
+
+ return x_grad;
+}
+
 std::tuple<Tensor, Tensor, Tensor, Tensor, Tensor, Tensor> batch_norm_impl(
  const Tensor& x,
  const Tensor& scale,
@@ -504,5 +508,50 @@ std::vector<Tensor> concat_grad_impl(const std::vector<Tensor>& x,
  return x_grad;
 }
 
+std::vector<Tensor> stack_grad_impl(const std::vector<Tensor>& x,
+ const Tensor& out_grad,
+ int axis) {
+ auto kernel_key_set = ParseKernelKeyByInputArgs(out_grad);
+ auto kernel_key = kernel_key_set.GetHighestPriorityKernelKey();
+
+ Backend kernel_backend = kernel_key.backend();
+ DataLayout kernel_layout = kernel_key.layout();
+ DataType kernel_data_type = kernel_key.dtype();
+
+ auto kernel = phi::KernelFactory::Instance().SelectKernelOrThrowError(
+ "stack_grad", {kernel_backend, kernel_layout, kernel_data_type});
+ VLOG(6) << "stack_grad API kernel key: [" << kernel_backend << ", "
+ << kernel_layout << ", " << kernel_data_type << "]";
+ VLOG(6) << "stack_grad API kernel: " << kernel;
+
+ auto* dev_ctx = GetDeviceContextByBackend(kernel_backend);
+
+ auto dense_out_grad = PrepareData(out_grad, kernel.InputAt(0), {});
+
+ size_t out_number = x.size();
+ std::vector<Tensor> x_grad;
+ auto dense_x_grad = SetKernelOutput(out_number, kernel_backend, &x_grad);
+ std::vector<phi::MetaTensor> meta_x_grad;
+ meta_x_grad.reserve(out_number);
+ std::vector<phi::MetaTensor*> meta_x_grad_ptrs;
+ meta_x_grad_ptrs.reserve(out_number);
+ for (size_t i = 0; i < out_number; ++i) {
+ meta_x_grad.push_back(dense_x_grad[i]);
+ meta_x_grad_ptrs.push_back(&meta_x_grad.back());
+ }
+
+ phi::StackGradInferMeta(
+ MakeMetaTensor(*dense_out_grad), axis, meta_x_grad_ptrs);
+
+ using kernel_signature = void (*)(const platform::DeviceContext&,
+ const phi::DenseTensor&,
+ int axis,
+ std::vector<phi::DenseTensor*>);
+ auto* kernel_fn = kernel.GetVariadicKernelFn<kernel_signature>();
+ (*kernel_fn)(*dev_ctx, *dense_out_grad, axis, dense_x_grad);
+
+ return x_grad;
+}
+
 } // namespace experimental
 } // namespace paddle