Merge branch 'PaddlePaddle:develop' into corrcoef

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

@@ -45,7 +45,7 @@
     'int' : 'int', 'int32_t' : 'int32_t', 'int64_t' : 'int64_t',  'size_t' : 'size_t', \
     'float' : 'float', 'double' : 'double', 'bool' : 'bool', \
     'str' : 'std::string', \
-    'Place' : 'paddle::experimental::Place', 'DataLayout' : 'paddle::experimental::DataLayout', 'DataType' : 'paddle::experimental::DataType', \
+    'Place' : 'paddle::Place', 'DataLayout' : 'paddle::experimental::DataLayout', 'DataType' : 'paddle::experimental::DataType', \
     'int64_t[]' : 'std::vector<int64_t>', 'int[]' : 'std::vector<int>',
     'Tensor' : 'Tensor',
     'Tensor[]' : 'std::vector<Tensor>',

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

@@ -46,7 +46,7 @@ def SkipAPIGeneration(forward_api_name):
     "std::vector<std::string>": "CastPyArg2Strings",
     "paddle::experimental::Scalar": "CastPyArg2Scalar",
     "paddle::experimental::IntArray": "CastPyArg2IntArray",
-    "paddle::experimental::Place": "CastPyArg2Place",
+    "paddle::Place": "CastPyArg2Place",
     "paddle::experimental::DataType": "CastPyArg2DataType",
 }
 

paddle/fluid/pybind/eager_method.cc

@@ -41,6 +41,7 @@ limitations under the License. */
 #include "paddle/phi/core/sparse_csr_tensor.h"
 #include "pybind11/detail/internals.h"
 #pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#include "paddle/fluid/eager/api/generated/eager_generated/forwards/dygraph_functions.h"
 #include "paddle/fluid/framework/python_headers.h"
 #include "paddle/fluid/memory/allocation/mmap_allocator.h"
 #include "paddle/fluid/pybind/tensor_py.h"
@@ -713,15 +714,19 @@ static PyObject* tensor__getitem_index_not_tensor(TensorObject* self,
         break;
       }
     }
+    std::vector<int64_t> slice_axes_tmp(slice_axes.begin(), slice_axes.end());
+    std::vector<int64_t> infer_flags_tmp(infer_flags.begin(),
+                                         infer_flags.end());
+    std::vector<int64_t> decrease_axis_tmp(decrease_axis.begin(),
+                                           decrease_axis.end());
+
     if (op_type == "slice") {
-      out = slice_dygraph_function(self->tensor, paddle::experimental::Tensor(),
-                                   paddle::experimental::Tensor(), {}, {},
-                                   std::move(attrs));
+      out = slice_final_state_dygraph_function(
+          self->tensor, slice_axes_tmp, slice_starts, slice_ends,
+          infer_flags_tmp, decrease_axis_tmp);
     } else if (op_type == "strided_slice") {
-      out = strided_slice_dygraph_function(
-          self->tensor, paddle::experimental::Tensor(),
-          paddle::experimental::Tensor(), paddle::experimental::Tensor(), {},
-          {}, {}, attrs);
+      out = strided_slice_final_state_dygraph_function(
+          self->tensor, slice_axes, slice_starts, slice_ends, slice_strides);
     } else {
       PADDLE_THROW(platform::errors::InvalidArgument(
           "Slice is only support slice and strided_slice, but we got %s which "
@@ -776,8 +781,8 @@ static PyObject* tensor__getitem_index_not_tensor(TensorObject* self,
     paddle::framework::TensorFromVector(list_select_idxs, *dev_ctx,
                                         idx_tensor.get());
     framework::AttributeMap attrs = {{"dim", 0}};
-    out = index_select_dygraph_function(self->tensor, select_index,
-                                        std::move(attrs));
+    out = index_select_final_state_dygraph_function(self->tensor, select_index,
+                                                    0);
   }
 
   return ToPyObject(out);

paddle/fluid/pybind/eager_utils.cc

@@ -1027,22 +1027,22 @@ paddle::experimental::Scalar CastPyArg2Scalar(PyObject* obj,
   // obj could be: int, float, bool, paddle.Tensor
   PyTypeObject* type = obj->ob_type;
   auto type_name = std::string(type->tp_name);
-  if (type_name == "int") {
+  if (PyBool_Check(obj)) {
+    bool value = CastPyArg2Boolean(obj, op_type, arg_pos);
+    return paddle::experimental::Scalar(value);
+  } else if (PyLong_Check(obj)) {
     int value = CastPyArg2Int(obj, op_type, arg_pos);
     return paddle::experimental::Scalar(value);
-  } else if (type_name == "float") {
+  } else if (PyFloat_Check(obj)) {
     float value = CastPyArg2Float(obj, op_type, arg_pos);
     return paddle::experimental::Scalar(value);
-
-  } else if (type_name == "bool") {
-    bool value = CastPyArg2Boolean(obj, op_type, arg_pos);
-    return paddle::experimental::Scalar(value);
-
-  } else if (type_name == "Tensor") {
+  } else if (IsEagerTensor(obj)) {
     paddle::experimental::Tensor& value = GetTensorFromPyObject(
         op_type, "" /*arg_name*/, obj, arg_pos, false /*dispensable*/);
     return paddle::experimental::Scalar(value);
-
+  } else if (PyObject_CheckLongOrToLong(&obj)) {
+    int value = CastPyArg2Int(obj, op_type, arg_pos);
+    return paddle::experimental::Scalar(value);
   } else {
     PADDLE_THROW(platform::errors::InvalidArgument(
         "%s(): argument (position %d) must be "
@@ -1151,21 +1151,15 @@ std::vector<paddle::framework::Scope*> GetScopePtrListFromArgs(
   return result;
 }
 
-paddle::experimental::Place CastPyArg2Place(PyObject* obj,
-                                            const std::string& op_type,
-                                            ssize_t arg_pos) {
+paddle::Place CastPyArg2Place(PyObject* obj, const std::string& op_type,
+                              ssize_t arg_pos) {
   return CastPyArg2Place(obj, arg_pos);
 }
 
-paddle::experimental::DataType CastPyArg2DataType(PyObject* obj,
-                                                  const std::string& op_type,
-                                                  ssize_t arg_pos) {
+paddle::DataType CastPyArg2DataType(PyObject* obj, const std::string& op_type,
+                                    ssize_t arg_pos) {
   if (obj == Py_None) {
-    PADDLE_THROW(platform::errors::InvalidArgument(
-        "%s(): argument (position %d) must be "
-        "data_type, but got %s",
-        op_type, arg_pos + 1,
-        ((PyTypeObject*)obj->ob_type)->tp_name));  // NOLINT
+    return paddle::experimental::DataType::UNDEFINED;
   }
 
   framework::proto::VarType::Type type = CastPyArg2ProtoType(obj, arg_pos);

paddle/fluid/pybind/eager_utils.h

@@ -162,13 +162,11 @@ paddle::experimental::IntArray CastPyArg2IntArray(PyObject* obj,
                                                   const std::string& op_type,
                                                   ssize_t arg_pos);
 
-paddle::experimental::Place CastPyArg2Place(PyObject* obj,
-                                            const std::string& op_type,
-                                            ssize_t arg_pos);
+paddle::Place CastPyArg2Place(PyObject* obj, const std::string& op_type,
+                              ssize_t arg_pos);
 
-paddle::experimental::DataType CastPyArg2DataType(PyObject* obj,
-                                                  const std::string& op_type,
-                                                  ssize_t arg_pos);
+paddle::DataType CastPyArg2DataType(PyObject* obj, const std::string& op_type,
+                                    ssize_t arg_pos);
 
 paddle::optional<const paddle::experimental::Tensor&> GetOptionalTensorFromArgs(
     const std::string& op_type, const std::string& arg_name, PyObject* args,

paddle/phi/common/place.h

@@ -213,9 +213,6 @@ std::ostream& operator<<(std::ostream&, const Place&);
 namespace paddle {
 namespace experimental {
 using AllocationType = phi::AllocationType;
-using Place = phi::Place;
-using CPUPlace = phi::CPUPlace;
-using GPUPlace = phi::GPUPlace;
 using GPUPinnedPlace = phi::GPUPinnedPlace;
 using XPUPlace = phi::XPUPlace;
 using NPUPlace = phi::NPUPlace;

paddle/phi/tests/api/test_data_transform.cc

@@ -37,13 +37,11 @@ namespace tests {
 // TODO(chenweihang): Remove this test after the API is used in the dygraph
 TEST(API, data_transform_same_place) {
   // 1. create tensor
-  auto x = paddle::experimental::full({3, 3},
-                                      1.0,
-                                      experimental::DataType::COMPLEX128,
-                                      experimental::CPUPlace());
+  auto x =
+      paddle::experimental::full({3, 3}, 1.0, DataType::COMPLEX128, CPUPlace());
 
-  auto y = paddle::experimental::full(
-      {3, 3}, 2.0, experimental::DataType::FLOAT32, experimental::CPUPlace());
+  auto y =
+      paddle::experimental::full({3, 3}, 2.0, DataType::FLOAT32, CPUPlace());
 
   std::vector<phi::dtype::complex<double>> sum(9, 6.0);
 
@@ -75,10 +73,10 @@ TEST(API, data_transform_same_place) {
 TEST(Tensor, data_transform_diff_place) {
   // 1. create tensor
   auto x = paddle::experimental::full(
-      {3, 3}, 1.0, experimental::DataType::FLOAT64, experimental::CPUPlace());
+      {3, 3}, 1.0, experimental::DataType::FLOAT64, CPUPlace());
 
   auto y = paddle::experimental::full(
-      {3, 3}, 2.0, experimental::DataType::FLOAT64, experimental::GPUPlace());
+      {3, 3}, 2.0, experimental::DataType::FLOAT64, GPUPlace());
 
   std::vector<float> sum(9, 6.0);
 
@@ -93,10 +91,9 @@ TEST(Tensor, data_transform_diff_place) {
   ASSERT_EQ(out.dtype(), phi::DataType::FLOAT64);
   ASSERT_EQ(out.layout(), phi::DataLayout::NCHW);
   ASSERT_EQ(out.initialized(), true);
-  ASSERT_EQ(out.impl()->place(),
-            phi::TransToPhiPlace(experimental::Backend::GPU));
+  ASSERT_EQ(out.impl()->place(), phi::TransToPhiPlace(phi::Backend::GPU));
 
-  auto ref_out = experimental::copy_to(out, experimental::CPUPlace(), true);
+  auto ref_out = experimental::copy_to(out, CPUPlace(), true);
 
   auto dense_out = std::dynamic_pointer_cast<phi::DenseTensor>(ref_out.impl());
   for (size_t i = 0; i < 9; i++) {

paddle/phi/tests/api/test_scale_benchmark.cc

@@ -30,7 +30,7 @@ namespace tests {
 
 TEST(API, scale) {
   auto x = experimental::full(
-      {3, 4}, 1.0, experimental::DataType::FLOAT32, experimental::CPUPlace());
+      {3, 4}, 1.0, experimental::DataType::FLOAT32, CPUPlace());
 
   const size_t cycles = 300;
   phi::tests::Timer timer;

python/paddle/fluid/clip.py

@@ -543,7 +543,7 @@ def _dygraph_clip(self, params_grads):
                 clip_input = (clip_var.astype('float16')
                               if g.dtype == core.VarDesc.VarType.FP16 else
                               clip_var)
-                new_grad = layers.elementwise_mul(x=g, y=clip_input)
+                new_grad = _C_ops.elementwise_mul(g, clip_input)
                 params_and_grads.append((p, new_grad))
             else:
                 params_and_grads.append((p, g))

python/paddle/fluid/dygraph/math_op_patch.py

@@ -62,15 +62,6 @@
 _already_patch_varbase = False
 _already_patch_eager_tensor = False
 
-# Dispatch to final state Python-C functions
-_final_state_op_type_mapping = {
-    "elementwise_add": "final_state_add",
-    "elementwise_sub": "final_state_subtract",
-    "elementwise_div": "final_state_divide",
-    "elementwise_mul": "final_state_multiply",
-    "matmul_v2": "final_state_matmul",
-}
-
 
 def monkey_patch_math_varbase():
     """
@@ -80,9 +71,13 @@ def monkey_patch_math_varbase():
 
     @no_grad
     def create_tensor(value, dtype, shape):
-        out = _varbase_creator(dtype=dtype)
-        out = _C_ops.fill_constant(out, 'dtype', dtype, 'shape', shape, 'value',
-                                   value, 'force_cpu', False)
+        if framework._in_eager_mode_:
+            out = _C_ops.final_state_full(shape, value, dtype,
+                                          framework._current_expected_place())
+        else:
+            out = _varbase_creator(dtype=dtype)
+            out = _C_ops.fill_constant(out, 'dtype', dtype, 'shape', shape,
+                                       'value', value, 'force_cpu', False)
         out.stop_gradient = True
         return out
 
@@ -120,9 +115,9 @@ def astype(self, dtype):
         return _C_ops.final_state_cast(self, dtype)
 
     def _scalar_elementwise_op_(var, scale, bias):
-        if _in_legacy_dygraph():
-            return _C_ops.scale(var, 'scale', scale, 'bias', bias)
-        return _C_ops.final_state_scale(var, float(scale), bias, True)
+        if framework.in_dygraph_mode():
+            return _C_ops.final_state_scale(var, float(scale), bias, True)
+        return _C_ops.scale(var, 'scale', scale, 'bias', bias)
 
     def _neg_(var):
         return _scalar_elementwise_op_(var, -1.0, 0.0)
@@ -203,7 +198,8 @@ def _scalar_div_(var, value):
     def _binary_creator_(method_name,
                          op_type,
                          reverse=False,
-                         scalar_method=None):
+                         scalar_method=None,
+                         call_final_api=False):
         def __impl__(self, other_var):
             # 1. scalar exists cases
             # we need combine the tensor.dtype and scalar.dtype, cast correct object
@@ -287,15 +283,15 @@ def __impl__(self, other_var):
 
             # 4. calculation
             axis = -1
-            if in_dygraph_mode(
-            ) and op_type in _final_state_op_type_mapping.keys():
-                math_op = getattr(_C_ops, _final_state_op_type_mapping[op_type])
-                return math_op(self, other_var)
-            else:
-                math_op = getattr(_C_ops, op_type)
-                return math_op(self, other_var, 'axis', axis)
+            math_op = getattr(_C_ops, op_type)
+            if call_final_api:
+                return math_op(self, other_var, -1)
+            return math_op(self, other_var, 'axis', axis)
 
-        comment = OpProtoHolder.instance().get_op_proto(op_type).comment
+        if call_final_api:
+            comment = ""
+        else:
+            comment = OpProtoHolder.instance().get_op_proto(op_type).comment
 
         __impl__.__doc__ = """
         {0}
@@ -321,28 +317,48 @@ def __impl__(self, other_var):
         ('ndim', _ndim_),
         ('size', _size_),
         ('T', _T_),
-        ('__add__',
-         _binary_creator_('__add__', 'elementwise_add', False, _scalar_add_)),
+        ('__add__', _binary_creator_('__add__', 'final_state_add', False,
+                                     _scalar_add_, True))
+        if framework._in_eager_mode_ else ('__add__', _binary_creator_(
+            '__add__', 'elementwise_add', False, _scalar_add_)),
         ##  a+b == b+a. Do not need to reverse explicitly
-        ('__radd__',
-         _binary_creator_('__radd__', 'elementwise_add', False, _scalar_add_)),
-        ('__sub__', _binary_creator_('__sub__', 'elementwise_sub', False,
-                                     _scalar_sub_)),
-        ('__rsub__', _binary_creator_('__rsub__', 'elementwise_sub', True,
-                                      _scalar_rsub_)),
-        ('__mul__', _binary_creator_('__mul__', 'elementwise_mul', False,
-                                     _scalar_mul_)),
+        ('__radd__', _binary_creator_('__radd__', 'final_state_add', False,
+                                      _scalar_add_, True))
+        if framework._in_eager_mode_ else ('__radd__', _binary_creator_(
+            '__radd__', 'elementwise_add', False, _scalar_add_)),
+        ('__sub__', _binary_creator_('__sub__', 'final_state_subtract', False,
+                                     _scalar_sub_, True))
+        if framework._in_eager_mode_ else ('__sub__', _binary_creator_(
+            '__sub__', 'elementwise_sub', False, _scalar_sub_)),
+        ('__rsub__', _binary_creator_('__rsub__', 'final_state_subtract', True,
+                                      _scalar_rsub_, True))
+        if framework._in_eager_mode_ else ('__rsub__', _binary_creator_(
+            '__rsub__', 'elementwise_sub', True, _scalar_rsub_)),
+        ('__mul__', _binary_creator_('__mul__', 'final_state_multiply', False,
+                                     _scalar_mul_, True))
+        if framework._in_eager_mode_ else ('__mul__', _binary_creator_(
+            '__mul__', 'elementwise_mul', False, _scalar_mul_)),
         ## a*b == b*a. Do not need to reverse explicitly
-        ('__rmul__',
-         _binary_creator_('__rmul__', 'elementwise_mul', False, _scalar_mul_)),
-        ('__div__', _binary_creator_('__div__', 'elementwise_div', False,
-                                     _scalar_div_)),
-        ('__truediv__', _binary_creator_('__truediv__', 'elementwise_div',
-                                         False, _scalar_div_)),
-        ('__rdiv__', _binary_creator_('__rdiv__', 'elementwise_div', True,
-                                      None)),
-        ('__rtruediv__', _binary_creator_('rtruediv__', 'elementwise_div', True,
-                                          None)),
+        ('__rmul__', _binary_creator_('__rmul__', 'final_state_multiply', False,
+                                      _scalar_mul_, True))
+        if framework._in_eager_mode_ else ('__rmul__', _binary_creator_(
+            '__rmul__', 'elementwise_mul', False, _scalar_mul_)),
+        ('__div__', _binary_creator_('__div__', 'final_state_divide', False,
+                                     _scalar_div_, True))
+        if framework._in_eager_mode_ else ('__div__', _binary_creator_(
+            '__div__', 'elementwise_div', False, _scalar_div_)),
+        ('__truediv__', _binary_creator_('__truediv__', 'final_state_divide',
+                                         False, _scalar_div_, True))
+        if framework._in_eager_mode_ else ('__truediv__', _binary_creator_(
+            '__truediv__', 'elementwise_div', False, _scalar_div_)),
+        ('__rdiv__', _binary_creator_('__rdiv__', 'final_state_divide', True,
+                                      None, True)) if framework._in_eager_mode_
+        else ('__rdiv__', _binary_creator_('__rdiv__', 'elementwise_div', True,
+                                           None)),
+        ('__rtruediv__', _binary_creator_('rtruediv__', 'final_state_divide',
+                                          True, None, True))
+        if framework._in_eager_mode_ else ('__rtruediv__', _binary_creator_(
+            'rtruediv__', 'elementwise_div', True, None)),
         ('__pow__', _binary_creator_('__pow__', 'elementwise_pow', False,
                                      None)),
         ('__rpow__', _binary_creator_('__rpow__', 'elementwise_pow', True,
@@ -354,11 +370,26 @@ def __impl__(self, other_var):
         ('__matmul__', _binary_creator_('__matmul__', "matmul_v2", False,
                                         None)),
         ## for logical compare
+        ('__eq__',
+         _binary_creator_('__eq__', 'final_state_equal', False, None, True))
+        if framework._in_eager_mode_ else
         ('__eq__', _binary_creator_('__eq__', 'equal', False, None)),
-        ('__ne__', _binary_creator_('__ne__', 'not_equal', False, None)),
-        ('__lt__', _binary_creator_('__lt__', 'less_than', False, None)),
-        ('__le__', _binary_creator_('__le__', 'less_equal', False, None)),
+        ('__ne__', _binary_creator_('__ne__', 'final_state_not_equal', False,
+                                    None, True)) if framework._in_eager_mode_
+        else ('__ne__', _binary_creator_('__ne__', 'not_equal', False, None)),
+        ('__lt__', _binary_creator_('__lt__', 'final_state_less_than', False,
+                                    None, True)) if framework._in_eager_mode_
+        else ('__lt__', _binary_creator_('__lt__', 'less_than', False, None)),
+        ('__le__', _binary_creator_('__le__', 'final_state_less_equal', False,
+                                    None, True)) if framework._in_eager_mode_
+        else ('__le__', _binary_creator_('__le__', 'less_equal', False, None)),
+        ('__gt__', _binary_creator_('__gt__', 'final_state_greater_than', False,
+                                    None, True))
+        if framework._in_eager_mode_ else
         ('__gt__', _binary_creator_('__gt__', 'greater_than', False, None)),
+        ('__ge__', _binary_creator_('__ge__', 'final_state_greater_equal',
+                                    False, None, True))
+        if framework._in_eager_mode_ else
         ('__ge__', _binary_creator_('__ge__', 'greater_equal', False, None)),
         ('__array_ufunc__', None)
     ]