remove experimental namespace of Tensor (#51155)

paddle/fluid/distributed/collective/reducer.h

@@ -33,10 +33,9 @@
 
 namespace paddle {
 namespace distributed {
-using Tensor = paddle::experimental::Tensor;
-using Scalar = paddle::experimental::ScalarBase<paddle::experimental::Tensor>;
-using IntArray =
-    paddle::experimental::IntArrayBase<paddle::experimental::Tensor>;
+using Tensor = paddle::Tensor;
+using Scalar = paddle::experimental::ScalarBase<paddle::Tensor>;
+using IntArray = paddle::experimental::IntArrayBase<paddle::Tensor>;
 using Backend = paddle::experimental::Backend;
 
 std::vector<std::vector<size_t>> Eager_AssignGroupBySize(

paddle/fluid/eager/accumulation/accumulation_node.cc

@@ -28,8 +28,8 @@
 
 namespace egr {
 
-static void CopyOrAddTensor(paddle::experimental::Tensor* tensor,
-                            const paddle::experimental::Tensor& t,
+static void CopyOrAddTensor(paddle::Tensor* tensor,
+                            const paddle::Tensor& t,
                             bool is_fake_empty) {
   if (is_fake_empty) {
     VLOG(3) << "Move Tensor ptr: " << t.impl();
@@ -48,15 +48,14 @@ static void CopyOrAddTensor(paddle::experimental::Tensor* tensor,
           if (t.is_custom_device()) {
             *tensor = add_ad_func(t, *tensor);
           } else {
-            paddle::imperative::TensorAdd<paddle::experimental::Tensor>(t,
-                                                                        tensor);
+            paddle::imperative::TensorAdd<paddle::Tensor>(t, tensor);
           }
         } else {
           // TODO(jiabin): Support Other TensorBase later
           // TODO(zhanlve): Replace SelectedRowsAddTensor with
           // add_dygraph_function once it's supported
-          paddle::experimental::Tensor new_buffer(
-              std::make_shared<phi::DenseTensor>(), "tmp_accumulator");
+          paddle::Tensor new_buffer(std::make_shared<phi::DenseTensor>(),
+                                    "tmp_accumulator");
           paddle::imperative::SelectedRowsAddTensor(*tensor, t, &new_buffer);
           tensor->set_impl(new_buffer.impl());
         }
@@ -65,19 +64,17 @@ static void CopyOrAddTensor(paddle::experimental::Tensor* tensor,
         if (LIKELY(tensor->is_sparse_coo_tensor())) {
           auto t_sparse =
               std::dynamic_pointer_cast<phi::SparseCooTensor>(t.impl());
-          paddle::experimental::Tensor t_values(
-              std::make_shared<phi::DenseTensor>(
-                  t_sparse->non_zero_elements()));
+          paddle::Tensor t_values(std::make_shared<phi::DenseTensor>(
+              t_sparse->non_zero_elements()));
           auto tensor_sparse =
               std::dynamic_pointer_cast<phi::SparseCooTensor>(tensor->impl());
-          paddle::experimental::Tensor tensor_values(
-              std::make_shared<phi::DenseTensor>(
-                  tensor_sparse->non_zero_elements()));
+          paddle::Tensor tensor_values(std::make_shared<phi::DenseTensor>(
+              tensor_sparse->non_zero_elements()));
           if (t.is_custom_device()) {
             tensor_values = add_ad_func(t_values, tensor_values);
           } else {
-            paddle::imperative::TensorAdd<paddle::experimental::Tensor>(
-                t_values, &tensor_values);
+            paddle::imperative::TensorAdd<paddle::Tensor>(t_values,
+                                                          &tensor_values);
           }
         }
       } else {
@@ -88,18 +85,18 @@ static void CopyOrAddTensor(paddle::experimental::Tensor* tensor,
         if (tensor->is_dense_tensor()) {
           paddle::imperative::SelectedRowsAddToTensor(t, tensor);
         } else {
-          *tensor = std::move(*paddle::imperative::SelectedRowsMerge<
-                              paddle::experimental::Tensor>(t, *tensor));
+          *tensor =
+              std::move(*paddle::imperative::SelectedRowsMerge<paddle::Tensor>(
+                  t, *tensor));
         }
       }
     }
   }
 }
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
 GradNodeAccumulation::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    paddle::small_vector<std::vector<paddle::Tensor>,
                          kSlotSmallVectorSize>& grads,  // NOLINT
     bool create_graph,
     bool is_new_grad) {
@@ -116,10 +113,9 @@ GradNodeAccumulation::operator()(
                      grads[0].size(),
                      0));
   // Apply Gradient Hooks
-  paddle::experimental::Tensor grad_out;
+  paddle::Tensor grad_out;
   if (GradientHooksRegistered()) {
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         kSlotSmallVectorSize>
+    paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
         hooked_grads = ApplyGradientHooks(grads);
     grad_out = hooked_grads[0][0];
   } else {

paddle/fluid/eager/accumulation/accumulation_node.h

@@ -37,9 +37,9 @@ class GradNodeAccumulation : public GradNodeBase {
   }
 
   // Functor: perform backward computations
-  virtual paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  virtual paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>
-  operator()(paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  operator()(paddle::small_vector<std::vector<paddle::Tensor>,
                                   kSlotSmallVectorSize>& grads,  // NOLINT
              bool create_graph = false,
              bool is_new_grad = false) override;
@@ -69,11 +69,9 @@ class GradNodeAccumulation : public GradNodeBase {
  private:
   // TODO(Jiabin): remove this when we make our clear gradient really cleared;
   bool is_fake_empty_ = {false};
-  std::weak_ptr<paddle::experimental::Tensor> weak_grad_;
+  std::weak_ptr<paddle::Tensor> weak_grad_;
   std::vector<std::shared_ptr<VoidHook>> reduce_hooks_;
-  std::function<paddle::experimental::Tensor(
-      const paddle::experimental::Tensor&)>
-      retain_grad_hook_;
+  std::function<paddle::Tensor(const paddle::Tensor&)> retain_grad_hook_;
 };
 
 }  // namespace egr

paddle/fluid/eager/amp_auto_cast.h

@@ -20,7 +20,7 @@
 
 namespace egr {
 
-static inline bool NeedCast(const paddle::experimental::Tensor& tensor,
+static inline bool NeedCast(const paddle::Tensor& tensor,
                             const paddle::experimental::DataType& dst_dtype) {
   auto place = tensor.place();
   auto data_type = tensor.dtype();
@@ -42,15 +42,15 @@ static inline bool NeedCast(const paddle::experimental::Tensor& tensor,
   return false;
 }
 
-inline std::vector<paddle::experimental::Tensor> AmpAutoCasts(
+inline std::vector<paddle::Tensor> AmpAutoCasts(
     const std::string& inputs_name,
-    const std::vector<paddle::experimental::Tensor>& inputs,
+    const std::vector<paddle::Tensor>& inputs,
     const paddle::experimental::DataType& dst_dtype,
     std::string op_name) {
   VLOG(6) << "AMP AmpAutoCasts:"
           << " inputs(" << inputs_name << ") dst_dtype("
           << phi::DataTypeToString(dst_dtype) << ").";
-  std::vector<paddle::experimental::Tensor> inputs_casted;
+  std::vector<paddle::Tensor> inputs_casted;
   for (auto& input : inputs) {
     if (NeedCast(input, dst_dtype)) {
       paddle::framework::AttributeMap cast_attrs = {
@@ -65,9 +65,9 @@ inline std::vector<paddle::experimental::Tensor> AmpAutoCasts(
   return inputs_casted;
 }
 
-inline paddle::experimental::Tensor AmpAutoCast(
+inline paddle::Tensor AmpAutoCast(
     const std::string& input_name,
-    const paddle::experimental::Tensor& input,
+    const paddle::Tensor& input,
     const paddle::experimental::DataType& dst_dtype,
     std::string op_name) {
   VLOG(6) << "AMP AmpAutoCasts:"

paddle/fluid/eager/amp_utils.h

@@ -22,7 +22,7 @@ namespace egr {
 
 static inline paddle::experimental::DataType GetPromoteType(
     const std::string& op_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& amp_tensors_vector,
     const paddle::experimental::DataType& amp_dtype) {
   auto dst_type = amp_dtype;
@@ -87,7 +87,7 @@ static inline paddle::experimental::DataType GetPromoteType(
 
 inline paddle::experimental::DataType GetDtypeWithPlace(
     const std::string& op_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& amp_tensors_vector,
     const paddle::experimental::DataType amp_dtype) {
   if (amp_dtype == paddle::experimental::DataType::FLOAT32) {
@@ -120,7 +120,7 @@ inline paddle::experimental::DataType GetDtypeWithPlace(
 
 inline paddle::experimental::DataType GetAmpDestDtype(
     const std::string& op_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& amp_tensors_vector) {
   auto amp_dtype =
       egr::Controller::Instance().GetCurrentTracer()->GetAmpDtype();

paddle/fluid/eager/api/generated/eager_generated/backwards/scale_node.cc

@@ -93,11 +93,11 @@ static void ScaleDeviceDispatch(const phi::DenseTensor& dense_tensor,
   }
 }
 
-void ScaleAPI(const paddle::experimental::Tensor& x,
+void ScaleAPI(const paddle::Tensor& x,
               float scale,
               float bias,
               bool bias_after_scale,
-              paddle::experimental::Tensor* out) {
+              paddle::Tensor* out) {
   // TODO(jiabin): Support multiple tensor here, Create DenseTensor is not a
   // proper way to Demo it
   // Run Forward Function
@@ -161,16 +161,15 @@ void ScaleAPI(const paddle::experimental::Tensor& x,
 }
 
 void GradNodeScale::SetTensorWrappers_X(
-    const std::vector<paddle::experimental::Tensor>& tensors) {
+    const std::vector<paddle::Tensor>& tensors) {
   // Does nothing for scale
 }
 
 void GradNodeScale::SetAttributes_scale(float scale) { scale_ = scale; }
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
 GradNodeScale::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    paddle::small_vector<std::vector<paddle::Tensor>,
                          kSlotSmallVectorSize>& grads,  // NOLINT
     bool create_graph,
     bool is_new_grad) {
@@ -183,17 +182,14 @@ GradNodeScale::operator()(
           "However received: %d",
           "This indicates an issue with Eager Dygraph Backward logic",
           grads.size()));
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
-      outs;
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize> outs;
   // 2. Create needed out parttern
-  paddle::experimental::Tensor out;
+  paddle::Tensor out;
   // Apply Gradient Hooks
   if (GradientHooksRegistered()) {
     // TODO(jiabin): Shall we apply hook slot by slot here or accept
     // vector<vector<phi::tensor>> to apply all hooks?
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         kSlotSmallVectorSize>
+    paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
         hooked_grads = ApplyGradientHooks(grads);
     ScaleAPI(/* slot by slot set */ hooked_grads[0][0],
              scale_,

paddle/fluid/eager/api/generated/eager_generated/backwards/scale_node.h

@@ -27,11 +27,11 @@
 */
 namespace egr {
 
-void ScaleAPI(const paddle::experimental::Tensor& x,
+void ScaleAPI(const paddle::Tensor& x,
               float scale,
               float bias,
               bool bias_after_scale,
-              paddle::experimental::Tensor* out);
+              paddle::Tensor* out);
 
 class GradNodeScale : public GradNodeBase {
  public:
@@ -41,17 +41,16 @@ class GradNodeScale : public GradNodeBase {
   ~GradNodeScale() override = default;
 
   // Functor: perform backward computations
-  virtual paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  virtual paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>
-  operator()(paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  operator()(paddle::small_vector<std::vector<paddle::Tensor>,
                                   kSlotSmallVectorSize>& grads,  // NOLINT
              bool create_graph = false,
              bool is_new_grad = false) override;
 
   void ClearTensorWrappers() override { VLOG(6) << "Do nothing here now"; }
 
-  void SetTensorWrappers_X(
-      const std::vector<paddle::experimental::Tensor>& tensors);
+  void SetTensorWrappers_X(const std::vector<paddle::Tensor>& tensors);
 
   void SetAttributes_scale(float scale);
   std::string name() override { return "scale node"; }

paddle/fluid/eager/api/generated/eager_generated/forwards/scale.cc

@@ -32,14 +32,14 @@
 
 namespace egr {
 
-paddle::experimental::Tensor scale(const paddle::experimental::Tensor& x,
-                                   float scale,
-                                   float bias,
-                                   bool bias_after_scale,
-                                   bool trace_backward) {
+paddle::Tensor scale(const paddle::Tensor& x,
+                     float scale,
+                     float bias,
+                     bool bias_after_scale,
+                     bool trace_backward) {
   // 1. Run Forward
   // 1.1 Create outputs
-  paddle::experimental::Tensor out;
+  paddle::Tensor out;
   // 1.2 Need by original op, we assemble ins, outs, attrs here
 
   // 1.3 Call forward C++ api

paddle/fluid/eager/api/generated/eager_generated/forwards/scale.h

@@ -17,10 +17,10 @@
 #include "paddle/fluid/eager/eager_tensor.h"
 namespace egr {
 
-paddle::experimental::Tensor scale(const paddle::experimental::Tensor& x,
-                                   float scale,
-                                   float bias,
-                                   bool bias_after_scale,
-                                   bool trace_backward);
+paddle::Tensor scale(const paddle::Tensor& x,
+                     float scale,
+                     float bias,
+                     bool bias_after_scale,
+                     bool trace_backward);
 
 }  // namespace egr

paddle/fluid/eager/api/manual/eager_manual/dygraph_forward_api.h

@@ -16,15 +16,13 @@
 
 #include "paddle/phi/api/include/tensor.h"
 
-paddle::experimental::Tensor add_n_ad_func(
-    const std::vector<paddle::experimental::Tensor>& x);
+paddle::Tensor add_n_ad_func(const std::vector<paddle::Tensor>& x);
 
-paddle::experimental::Tensor conv2d_ad_func(
-    const paddle::experimental::Tensor& input,
-    const paddle::experimental::Tensor& filter,
-    std::vector<int> strides,
-    std::vector<int> paddings,
-    std::string padding_algorithm,
-    std::vector<int> dilations,
-    int groups,
-    std::string data_format);
+paddle::Tensor conv2d_ad_func(const paddle::Tensor& input,
+                              const paddle::Tensor& filter,
+                              std::vector<int> strides,
+                              std::vector<int> paddings,
+                              std::string padding_algorithm,
+                              std::vector<int> dilations,
+                              int groups,
+                              std::string data_format);

paddle/fluid/eager/api/manual/eager_manual/forwards/add_n_fwd_func.cc

@@ -22,8 +22,7 @@
 
 DECLARE_bool(check_nan_inf);
 
-paddle::experimental::Tensor add_n_ad_func(
-    const std::vector<paddle::experimental::Tensor>& x) {
+paddle::Tensor add_n_ad_func(const std::vector<paddle::Tensor>& x) {
   // Dygraph Record Event
   paddle::platform::RecordEvent dygraph_entrance_record_event(
       "add_n dygraph", paddle::platform::TracerEventType::Operator, 1);
@@ -33,8 +32,7 @@ paddle::experimental::Tensor add_n_ad_func(
       paddle::imperative::AmpLevel::O0) {
     VLOG(5) << "Check and Prepare For AMP";
     auto op_name = phi::TransToFluidOpName("add_n");
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         egr::kSlotSmallVectorSize>
+    paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
         amp_tensors_vector = {x};
 
     auto amp_dst_dtype = egr::GetAmpDestDtype(op_name, amp_tensors_vector);

paddle/fluid/eager/api/manual/eager_manual/forwards/conv2d_fwd_function.cc

@@ -23,15 +23,14 @@
 
 DECLARE_bool(check_nan_inf);
 
-paddle::experimental::Tensor conv2d_ad_func(
-    const paddle::experimental::Tensor& input,
-    const paddle::experimental::Tensor& filter,
-    std::vector<int> strides,
-    std::vector<int> paddings,
-    std::string padding_algorithm,
-    std::vector<int> dilations,
-    int groups,
-    std::string data_format) {
+paddle::Tensor conv2d_ad_func(const paddle::Tensor& input,
+                              const paddle::Tensor& filter,
+                              std::vector<int> strides,
+                              std::vector<int> paddings,
+                              std::string padding_algorithm,
+                              std::vector<int> dilations,
+                              int groups,
+                              std::string data_format) {
   // Dygraph Record Event
   paddle::platform::RecordEvent dygraph_entrance_record_event(
       "conv2d dygraph", paddle::platform::TracerEventType::Operator, 1);
@@ -41,8 +40,7 @@ paddle::experimental::Tensor conv2d_ad_func(
       paddle::imperative::AmpLevel::O0) {
     VLOG(5) << "Check and Prepare For AMP";
     auto op_name = phi::TransToFluidOpName("conv2d");
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         egr::kSlotSmallVectorSize>
+    paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
         amp_tensors_vector = {{input}, {filter}};
 
     auto amp_dst_dtype = egr::GetAmpDestDtype(op_name, amp_tensors_vector);
@@ -71,8 +69,7 @@ paddle::experimental::Tensor conv2d_ad_func(
 
   if (egr::Controller::Instance().UseLayoutAutoTune()) {
     VLOG(5) << "Check and Prepare For LAYOUT";
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         egr::kSlotSmallVectorSize>
+    paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
         tensors_vector = {{input}, {filter}};
 
     auto op_name = phi::TransToFluidOpName("conv2d");

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

@@ -24,10 +24,9 @@
 #include "paddle/phi/api/lib/api_custom_impl.h"
 DECLARE_bool(check_nan_inf);
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     egr::kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
 AddNGradNodeFinal::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    paddle::small_vector<std::vector<paddle::Tensor>,
                          egr::kSlotSmallVectorSize>& grads,
     bool create_graph,
     bool is_new_grad) {
@@ -42,15 +41,14 @@ AddNGradNodeFinal::operator()(
   // Prepare Grad function call
 
   const auto& out_metas = OutputMeta();
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       returns(1);
   for (int i = 0; i < 1; ++i) {
     out_metas[i].size() == 0 ? returns[i].resize(1)
                              : returns[i].resize(out_metas[i].size());
   }
 
-  std::vector<paddle::experimental::Tensor*> api_output_0;
+  std::vector<paddle::Tensor*> api_output_0;
   api_output_0.reserve(returns[0].size());
   for (size_t i = 0; i < returns[0].size(); ++i) {
     if (out_metas[0].empty() || out_metas[0][i].IsStopGradient()) {

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

@@ -28,10 +28,9 @@
 #include "paddle/phi/api/include/sparse_api.h"
 DECLARE_bool(check_nan_inf);
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     egr::kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
 Conv2dGradNodeFinal::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    paddle::small_vector<std::vector<paddle::Tensor>,
                          egr::kSlotSmallVectorSize>& grads,
     bool create_graph,
     bool is_new_grad) {
@@ -53,8 +52,7 @@ Conv2dGradNodeFinal::operator()(
   // Prepare Grad function call
 
   const auto& out_metas = OutputMeta();
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       returns(2);
   for (int i = 0; i < 2; ++i) {
     out_metas[i].size() == 0 ? returns[i].resize(1)
@@ -167,10 +165,9 @@ Conv2dGradNodeFinal::operator()(
   return returns;
 }
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     egr::kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
 Conv2dDoubleGradNodeFinal::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    paddle::small_vector<std::vector<paddle::Tensor>,
                          egr::kSlotSmallVectorSize>& grads,
     bool create_graph,
     bool is_new_grad) {
@@ -190,17 +187,17 @@ Conv2dDoubleGradNodeFinal::operator()(
   auto grad_out = egr::EagerUtils::RecoverTensorWrapper(&this->grad_out_);
   auto& grad_input_grad = hooked_grads[0][0];
 
-  paddle::optional<paddle::experimental::Tensor> grad_input_grad_optional;
+  paddle::optional<paddle::Tensor> grad_input_grad_optional;
   if (grad_input_grad.initialized())
     grad_input_grad_optional =
-        paddle::make_optional<paddle::experimental::Tensor>(grad_input_grad);
+        paddle::make_optional<paddle::Tensor>(grad_input_grad);
 
   auto& grad_filter_grad = hooked_grads[1][0];
 
-  paddle::optional<paddle::experimental::Tensor> grad_filter_grad_optional;
+  paddle::optional<paddle::Tensor> grad_filter_grad_optional;
   if (grad_filter_grad.initialized())
     grad_filter_grad_optional =
-        paddle::make_optional<paddle::experimental::Tensor>(grad_filter_grad);
+        paddle::make_optional<paddle::Tensor>(grad_filter_grad);
 
   auto& strides = this->strides_;
   auto& paddings = this->paddings_;
@@ -211,8 +208,7 @@ Conv2dDoubleGradNodeFinal::operator()(
   // Prepare Grad function call
 
   const auto& out_metas = OutputMeta();
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       returns(3);
   for (int i = 0; i < 3; ++i) {
     out_metas[i].size() == 0 ? returns[i].resize(1)

paddle/fluid/eager/api/manual/eager_manual/nodes/nodes.h

@@ -24,13 +24,12 @@ class Conv2dGradNodeFinal : public egr::GradNodeBase {
       : egr::GradNodeBase(bwd_in_slot_num, bwd_out_slot_num) {}
   ~Conv2dGradNodeFinal() override = default;
 
-  virtual paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  virtual paddle::small_vector<std::vector<paddle::Tensor>,
                                egr::kSlotSmallVectorSize>
-  operator()(
-      paddle::small_vector<std::vector<paddle::experimental::Tensor>,  // NOLINT
-                           egr::kSlotSmallVectorSize>& grads,          // NOLINT
-      bool create_graph = false,                                       // NOLINT
-      bool is_new_grad = false) override;                              // NOLINT
+  operator()(paddle::small_vector<std::vector<paddle::Tensor>,        // NOLINT
+                                  egr::kSlotSmallVectorSize>& grads,  // NOLINT
+             bool create_graph = false,                               // NOLINT
+             bool is_new_grad = false) override;                      // NOLINT
   std::string name() override { return "Conv2dGradNodeFinal"; }
 
   void ClearTensorWrappers() override {
@@ -49,10 +48,10 @@ class Conv2dGradNodeFinal : public egr::GradNodeBase {
   }
 
   // SetTensorWrapperX, SetTensorWrapperY, ...
-  void SetTensorWrapperinput(const paddle::experimental::Tensor& input) {
+  void SetTensorWrapperinput(const paddle::Tensor& input) {
     input_ = egr::TensorWrapper(input, false);
   }
-  void SetTensorWrapperfilter(const paddle::experimental::Tensor& filter) {
+  void SetTensorWrapperfilter(const paddle::Tensor& filter) {
     filter_ = egr::TensorWrapper(filter, false);
   }
 
@@ -95,13 +94,12 @@ class Conv2dDoubleGradNodeFinal : public egr::GradNodeBase {
       : egr::GradNodeBase(bwd_in_slot_num, bwd_out_slot_num) {}
   ~Conv2dDoubleGradNodeFinal() override = default;
 
-  virtual paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  virtual paddle::small_vector<std::vector<paddle::Tensor>,
                                egr::kSlotSmallVectorSize>
-  operator()(
-      paddle::small_vector<std::vector<paddle::experimental::Tensor>,  // NOLINT
-                           egr::kSlotSmallVectorSize>& grads,          // NOLINT
-      bool create_graph = false,                                       // NOLINT
-      bool is_new_grad = false) override;                              // NOLINT
+  operator()(paddle::small_vector<std::vector<paddle::Tensor>,        // NOLINT
+                                  egr::kSlotSmallVectorSize>& grads,  // NOLINT
+             bool create_graph = false,                               // NOLINT
+             bool is_new_grad = false) override;                      // NOLINT
   std::string name() override { return "Conv2dDoubleGradNodeFinal"; }
 
   void ClearTensorWrappers() override {
@@ -119,13 +117,13 @@ class Conv2dDoubleGradNodeFinal : public egr::GradNodeBase {
   }
 
   // SetTensorWrapperX, SetTensorWrapperY, ...
-  void SetTensorWrapperinput(const paddle::experimental::Tensor& input) {
+  void SetTensorWrapperinput(const paddle::Tensor& input) {
     input_ = egr::TensorWrapper(input, false);
   }
-  void SetTensorWrapperfilter(const paddle::experimental::Tensor& filter) {
+  void SetTensorWrapperfilter(const paddle::Tensor& filter) {
     filter_ = egr::TensorWrapper(filter, false);
   }
-  void SetTensorWrappergrad_out(const paddle::experimental::Tensor& grad_out) {
+  void SetTensorWrappergrad_out(const paddle::Tensor& grad_out) {
     grad_out_ = egr::TensorWrapper(grad_out, false);
   }
 
@@ -169,13 +167,12 @@ class AddNGradNodeFinal : public egr::GradNodeBase {
       : egr::GradNodeBase(bwd_in_slot_num, bwd_out_slot_num) {}
   ~AddNGradNodeFinal() override = default;
 
-  virtual paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  virtual paddle::small_vector<std::vector<paddle::Tensor>,
                                egr::kSlotSmallVectorSize>
-  operator()(
-      paddle::small_vector<std::vector<paddle::experimental::Tensor>,  // NOLINT
-                           egr::kSlotSmallVectorSize>& grads,          // NOLINT
-      bool create_graph = false,
-      bool is_new_grad = false) override;
+  operator()(paddle::small_vector<std::vector<paddle::Tensor>,        // NOLINT
+                                  egr::kSlotSmallVectorSize>& grads,  // NOLINT
+             bool create_graph = false,
+             bool is_new_grad = false) override;
   std::string name() override { return "AddNGradNodeFinal"; }
 
   void ClearTensorWrappers() override {
@@ -193,7 +190,7 @@ class AddNGradNodeFinal : public egr::GradNodeBase {
   }
 
   // SetTensorWrapperX, SetTensorWrapperY, ...
-  void SetTensorWrapperx(const std::vector<paddle::experimental::Tensor>& x) {
+  void SetTensorWrapperx(const std::vector<paddle::Tensor>& x) {
     for (const auto& eager_tensor : x) {
       x_.emplace_back(egr::TensorWrapper(eager_tensor, true));
     }

paddle/fluid/eager/api/manual/fluid_manual/dygraph_forward_api.h

@@ -20,103 +20,103 @@
 #include "paddle/fluid/imperative/tracer.h"
 #include "paddle/phi/api/all.h"
 
-std::tuple<paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor>
+std::tuple<paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor>
 fused_gate_attention_dygraph_function(
-    const paddle::experimental::Tensor& Query,
-    const paddle::experimental::Tensor& Key,
-    const paddle::experimental::Tensor& QueryWeight,
-    const paddle::experimental::Tensor& KeyWeight,
-    const paddle::experimental::Tensor& ValueWeight,
-    const paddle::experimental::Tensor& QKVWeight,
-    const paddle::experimental::Tensor& NonbatchedBias,
-    const paddle::experimental::Tensor& SrcMask,
-    const paddle::experimental::Tensor& GateWeight,
-    const paddle::experimental::Tensor& GateBias,
-    const paddle::experimental::Tensor& OutLinearWeight,
-    const paddle::experimental::Tensor& OutLinearBias,
+    const paddle::Tensor& Query,
+    const paddle::Tensor& Key,
+    const paddle::Tensor& QueryWeight,
+    const paddle::Tensor& KeyWeight,
+    const paddle::Tensor& ValueWeight,
+    const paddle::Tensor& QKVWeight,
+    const paddle::Tensor& NonbatchedBias,
+    const paddle::Tensor& SrcMask,
+    const paddle::Tensor& GateWeight,
+    const paddle::Tensor& GateBias,
+    const paddle::Tensor& OutLinearWeight,
+    const paddle::Tensor& OutLinearBias,
     const paddle::framework::AttributeMap& attr_map);
 
-std::tuple<paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor>
+std::tuple<paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor>
 fused_feedforward_dygraph_function(
-    const paddle::experimental::Tensor& X,
-    const paddle::experimental::Tensor& Dropout1Seed,
-    const paddle::experimental::Tensor& Dropout2Seed,
-    const paddle::experimental::Tensor& Linear1Weight,
-    const paddle::experimental::Tensor& Linear1Bias,
-    const paddle::experimental::Tensor& Linear2Weight,
-    const paddle::experimental::Tensor& Linear2Bias,
-    const paddle::experimental::Tensor& Ln1Scale,
-    const paddle::experimental::Tensor& Ln1Bias,
-    const paddle::experimental::Tensor& Ln2Scale,
-    const paddle::experimental::Tensor& Ln2Bias,
+    const paddle::Tensor& X,
+    const paddle::Tensor& Dropout1Seed,
+    const paddle::Tensor& Dropout2Seed,
+    const paddle::Tensor& Linear1Weight,
+    const paddle::Tensor& Linear1Bias,
+    const paddle::Tensor& Linear2Weight,
+    const paddle::Tensor& Linear2Bias,
+    const paddle::Tensor& Ln1Scale,
+    const paddle::Tensor& Ln1Bias,
+    const paddle::Tensor& Ln2Scale,
+    const paddle::Tensor& Ln2Bias,
     const paddle::framework::AttributeMap& attr_map);
 
-std::tuple<paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor>
+std::tuple<paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor>
 fused_attention_dygraph_function(
-    const paddle::experimental::Tensor& X,
-    const paddle::experimental::Tensor& LnScale,
-    const paddle::experimental::Tensor& LnBias,
-    const paddle::experimental::Tensor& QKVW,
-    const paddle::experimental::Tensor& QKVBias,
-    const paddle::experimental::Tensor& CacheKV,
-    const paddle::experimental::Tensor& SrcMask,
-    const paddle::experimental::Tensor& OutLinearW,
-    const paddle::experimental::Tensor& OutLinearBias,
-    const paddle::experimental::Tensor& Ln2Scale,
-    const paddle::experimental::Tensor& Ln2Bias,
+    const paddle::Tensor& X,
+    const paddle::Tensor& LnScale,
+    const paddle::Tensor& LnBias,
+    const paddle::Tensor& QKVW,
+    const paddle::Tensor& QKVBias,
+    const paddle::Tensor& CacheKV,
+    const paddle::Tensor& SrcMask,
+    const paddle::Tensor& OutLinearW,
+    const paddle::Tensor& OutLinearBias,
+    const paddle::Tensor& Ln2Scale,
+    const paddle::Tensor& Ln2Bias,
     const paddle::framework::AttributeMap& attr_map);
 
-paddle::experimental::Tensor fused_gemm_epilogue_dygraph_function(
-    const paddle::experimental::Tensor& X,
-    const paddle::experimental::Tensor& Y,
-    const paddle::experimental::Tensor& Bias,
+paddle::Tensor fused_gemm_epilogue_dygraph_function(
+    const paddle::Tensor& X,
+    const paddle::Tensor& Y,
+    const paddle::Tensor& Bias,
     const paddle::framework::AttributeMap& attr_map);
 
-std::tuple<paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor>
+std::tuple<paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor>
 fused_bias_dropout_residual_layer_norm_dygraph_function(
-    const paddle::experimental::Tensor& X,
-    const paddle::experimental::Tensor& Residual,
-    const paddle::experimental::Tensor& Bias,
-    const paddle::experimental::Tensor& LnScale,
-    const paddle::experimental::Tensor& LnBias,
+    const paddle::Tensor& X,
+    const paddle::Tensor& Residual,
+    const paddle::Tensor& Bias,
+    const paddle::Tensor& LnScale,
+    const paddle::Tensor& LnBias,
     const paddle::framework::AttributeMap& attr_map);

paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_attention_fwd_func.cc

@@ -20,38 +20,38 @@
 #include "paddle/fluid/eager/api/utils/global_utils.h"
 #include "paddle/fluid/platform/profiler/event_tracing.h"
 
-std::tuple<paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor>
+std::tuple<paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor>
 fused_attention_dygraph_function(
-    const paddle::experimental::Tensor& X,
-    const paddle::experimental::Tensor& LnScale,
-    const paddle::experimental::Tensor& LnBias,
-    const paddle::experimental::Tensor& QKVW,
-    const paddle::experimental::Tensor& QKVBias,
-    const paddle::experimental::Tensor& CacheKV,
-    const paddle::experimental::Tensor& SrcMask,
-    const paddle::experimental::Tensor& OutLinearW,
-    const paddle::experimental::Tensor& OutLinearBias,
-    const paddle::experimental::Tensor& Ln2Scale,
-    const paddle::experimental::Tensor& Ln2Bias,
+    const paddle::Tensor& X,
+    const paddle::Tensor& LnScale,
+    const paddle::Tensor& LnBias,
+    const paddle::Tensor& QKVW,
+    const paddle::Tensor& QKVBias,
+    const paddle::Tensor& CacheKV,
+    const paddle::Tensor& SrcMask,
+    const paddle::Tensor& OutLinearW,
+    const paddle::Tensor& OutLinearBias,
+    const paddle::Tensor& Ln2Scale,
+    const paddle::Tensor& Ln2Bias,
     const paddle::framework::AttributeMap& attr_map) {
   paddle::platform::RecordEvent dygraph_entrance_record_event(
       "fused_attention dygraph",
@@ -64,8 +64,7 @@ fused_attention_dygraph_function(
       paddle::imperative::AmpLevel::O0) {
     VLOG(5) << "Check and Prepare For AMP";
 
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         egr::kSlotSmallVectorSize>
+    paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
         amp_tensors_vector = {{X}, {QKVW}, {OutLinearW}};
     if (LnScale.initialized()) amp_tensors_vector.push_back({LnScale});
     if (LnBias.initialized()) amp_tensors_vector.push_back({LnBias});
@@ -280,47 +279,47 @@ fused_attention_dygraph_function(
       true,
       {});
 
-  paddle::experimental::Tensor LnMean;
+  paddle::Tensor LnMean;
   egr::EagerUtils::GetOutput(outs["LnMean"][0], &LnMean);
-  paddle::experimental::Tensor LnVariance;
+  paddle::Tensor LnVariance;
   egr::EagerUtils::GetOutput(outs["LnVariance"][0], &LnVariance);
-  paddle::experimental::Tensor LnOut;
+  paddle::Tensor LnOut;
   egr::EagerUtils::GetOutput(outs["LnOut"][0], &LnOut);
-  paddle::experimental::Tensor QKVOut;
+  paddle::Tensor QKVOut;
   egr::EagerUtils::GetOutput(outs["QKVOut"][0], &QKVOut);
-  paddle::experimental::Tensor QKVBiasOut;
+  paddle::Tensor QKVBiasOut;
   egr::EagerUtils::GetOutput(outs["QKVBiasOut"][0], &QKVBiasOut);
-  paddle::experimental::Tensor TransposeOut2;
+  paddle::Tensor TransposeOut2;
   egr::EagerUtils::GetOutput(outs["TransposeOut2"][0], &TransposeOut2);
-  paddle::experimental::Tensor QKOut;
+  paddle::Tensor QKOut;
   egr::EagerUtils::GetOutput(outs["QKOut"][0], &QKOut);
-  paddle::experimental::Tensor QKTVOut;
+  paddle::Tensor QKTVOut;
   egr::EagerUtils::GetOutput(outs["QKTVOut"][0], &QKTVOut);
-  paddle::experimental::Tensor SoftmaxOut;
+  paddle::Tensor SoftmaxOut;
   egr::EagerUtils::GetOutput(outs["SoftmaxOut"][0], &SoftmaxOut);
-  paddle::experimental::Tensor AttnDropoutMaskOut;
+  paddle::Tensor AttnDropoutMaskOut;
   egr::EagerUtils::GetOutput(outs["AttnDropoutMaskOut"][0],
                              &AttnDropoutMaskOut);
-  paddle::experimental::Tensor AttnDropoutOut;
+  paddle::Tensor AttnDropoutOut;
   egr::EagerUtils::GetOutput(outs["AttnDropoutOut"][0], &AttnDropoutOut);
-  paddle::experimental::Tensor SrcMaskOut;
+  paddle::Tensor SrcMaskOut;
   egr::EagerUtils::GetOutput(outs["SrcMaskOut"][0], &SrcMaskOut);
-  paddle::experimental::Tensor FMHAOut;
+  paddle::Tensor FMHAOut;
   egr::EagerUtils::GetOutput(outs["FMHAOut"][0], &FMHAOut);
-  paddle::experimental::Tensor OutLinearOut;
+  paddle::Tensor OutLinearOut;
   egr::EagerUtils::GetOutput(outs["OutLinearOut"][0], &OutLinearOut);
-  paddle::experimental::Tensor DropoutMaskOut;
+  paddle::Tensor DropoutMaskOut;
   egr::EagerUtils::GetOutput(outs["DropoutMaskOut"][0], &DropoutMaskOut);
-  paddle::experimental::Tensor Ln2Mean;
+  paddle::Tensor Ln2Mean;
   egr::EagerUtils::GetOutput(outs["Ln2Mean"][0], &Ln2Mean);
-  paddle::experimental::Tensor Ln2Variance;
+  paddle::Tensor Ln2Variance;
   egr::EagerUtils::GetOutput(outs["Ln2Variance"][0], &Ln2Variance);
-  paddle::experimental::Tensor BiasDropoutResidualOut;
+  paddle::Tensor BiasDropoutResidualOut;
   egr::EagerUtils::GetOutput(outs["BiasDropoutResidualOut"][0],
                              &BiasDropoutResidualOut);
-  paddle::experimental::Tensor CacheKVOut;
+  paddle::Tensor CacheKVOut;
   egr::EagerUtils::GetOutput(outs["CacheKVOut"][0], &CacheKVOut);
-  paddle::experimental::Tensor Y;
+  paddle::Tensor Y;
   egr::EagerUtils::GetOutput(outs["Y"][0], &Y);
 
   {

paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_bias_dropout_residual_layer_norm_fwd_func.cc

@@ -20,17 +20,17 @@
 #include "paddle/fluid/eager/api/utils/global_utils.h"
 #include "paddle/fluid/platform/profiler/event_tracing.h"
 
-std::tuple<paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor>
+std::tuple<paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor>
 fused_bias_dropout_residual_layer_norm_dygraph_function(
-    const paddle::experimental::Tensor& X,
-    const paddle::experimental::Tensor& Residual,
-    const paddle::experimental::Tensor& Bias,
-    const paddle::experimental::Tensor& LnScale,
-    const paddle::experimental::Tensor& LnBias,
+    const paddle::Tensor& X,
+    const paddle::Tensor& Residual,
+    const paddle::Tensor& Bias,
+    const paddle::Tensor& LnScale,
+    const paddle::Tensor& LnBias,
     const paddle::framework::AttributeMap& attr_map) {
   paddle::platform::RecordEvent dygraph_entrance_record_event(
       "fused_bias_dropout_residual_layer_norm dygraph",
@@ -43,8 +43,7 @@ fused_bias_dropout_residual_layer_norm_dygraph_function(
       paddle::imperative::AmpLevel::O0) {
     VLOG(5) << "Check and Prepare For AMP";
 
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         egr::kSlotSmallVectorSize>
+    paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
         amp_tensors_vector = {{X}, {Residual}};
     if (Bias.initialized()) amp_tensors_vector.push_back({Bias});
     if (LnScale.initialized()) amp_tensors_vector.push_back({LnScale});
@@ -150,16 +149,16 @@ fused_bias_dropout_residual_layer_norm_dygraph_function(
       true,
       {});
 
-  paddle::experimental::Tensor BiasDropoutResidualOut;
+  paddle::Tensor BiasDropoutResidualOut;
   egr::EagerUtils::GetOutput(outs["BiasDropoutResidualOut"][0],
                              &BiasDropoutResidualOut);
-  paddle::experimental::Tensor DropoutMaskOut;
+  paddle::Tensor DropoutMaskOut;
   egr::EagerUtils::GetOutput(outs["DropoutMaskOut"][0], &DropoutMaskOut);
-  paddle::experimental::Tensor LnMean;
+  paddle::Tensor LnMean;
   egr::EagerUtils::GetOutput(outs["LnMean"][0], &LnMean);
-  paddle::experimental::Tensor LnVariance;
+  paddle::Tensor LnVariance;
   egr::EagerUtils::GetOutput(outs["LnVariance"][0], &LnVariance);
-  paddle::experimental::Tensor Y;
+  paddle::Tensor Y;
   egr::EagerUtils::GetOutput(outs["Y"][0], &Y);
 
   {

paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_feedforward_fwd_func.cc

@@ -19,29 +19,29 @@
 #include "paddle/fluid/eager/api/utils/global_utils.h"
 #include "paddle/fluid/platform/profiler/event_tracing.h"
 
-std::tuple<paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor>
+std::tuple<paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor>
 fused_feedforward_dygraph_function(
-    const paddle::experimental::Tensor& X,
-    const paddle::experimental::Tensor& Dropout1Seed,
-    const paddle::experimental::Tensor& Dropout2Seed,
-    const paddle::experimental::Tensor& Linear1Weight,
-    const paddle::experimental::Tensor& Linear1Bias,
-    const paddle::experimental::Tensor& Linear2Weight,
-    const paddle::experimental::Tensor& Linear2Bias,
-    const paddle::experimental::Tensor& Ln1Scale,
-    const paddle::experimental::Tensor& Ln1Bias,
-    const paddle::experimental::Tensor& Ln2Scale,
-    const paddle::experimental::Tensor& Ln2Bias,
+    const paddle::Tensor& X,
+    const paddle::Tensor& Dropout1Seed,
+    const paddle::Tensor& Dropout2Seed,
+    const paddle::Tensor& Linear1Weight,
+    const paddle::Tensor& Linear1Bias,
+    const paddle::Tensor& Linear2Weight,
+    const paddle::Tensor& Linear2Bias,
+    const paddle::Tensor& Ln1Scale,
+    const paddle::Tensor& Ln1Bias,
+    const paddle::Tensor& Ln2Scale,
+    const paddle::Tensor& Ln2Bias,
     const paddle::framework::AttributeMap& attr_map) {
   paddle::platform::RecordEvent dygraph_entrance_record_event(
       "fused_feedforward dygraph",
@@ -54,8 +54,7 @@ fused_feedforward_dygraph_function(
       paddle::imperative::AmpLevel::O0) {
     VLOG(5) << "Check and Prepare For AMP";
 
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         egr::kSlotSmallVectorSize>
+    paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
         amp_tensors_vector = {{X}, {Linear1Weight}, {Linear2Weight}};
     if (Dropout1Seed.initialized())
       amp_tensors_vector.push_back({Dropout1Seed});
@@ -247,27 +246,27 @@ fused_feedforward_dygraph_function(
       true,
       {});
 
-  paddle::experimental::Tensor Out;
+  paddle::Tensor Out;
   egr::EagerUtils::GetOutput(outs["Out"][0], &Out);
-  paddle::experimental::Tensor Dropout1Mask;
+  paddle::Tensor Dropout1Mask;
   egr::EagerUtils::GetOutput(outs["Dropout1Mask"][0], &Dropout1Mask);
-  paddle::experimental::Tensor Dropout2Mask;
+  paddle::Tensor Dropout2Mask;
   egr::EagerUtils::GetOutput(outs["Dropout2Mask"][0], &Dropout2Mask);
-  paddle::experimental::Tensor Ln1Mean;
+  paddle::Tensor Ln1Mean;
   egr::EagerUtils::GetOutput(outs["Ln1Mean"][0], &Ln1Mean);
-  paddle::experimental::Tensor Ln1Variance;
+  paddle::Tensor Ln1Variance;
   egr::EagerUtils::GetOutput(outs["Ln1Variance"][0], &Ln1Variance);
-  paddle::experimental::Tensor Ln2Mean;
+  paddle::Tensor Ln2Mean;
   egr::EagerUtils::GetOutput(outs["Ln2Mean"][0], &Ln2Mean);
-  paddle::experimental::Tensor Ln2Variance;
+  paddle::Tensor Ln2Variance;
   egr::EagerUtils::GetOutput(outs["Ln2Variance"][0], &Ln2Variance);
-  paddle::experimental::Tensor Linear1Out;
+  paddle::Tensor Linear1Out;
   egr::EagerUtils::GetOutput(outs["Linear1Out"][0], &Linear1Out);
-  paddle::experimental::Tensor Ln1Out;
+  paddle::Tensor Ln1Out;
   egr::EagerUtils::GetOutput(outs["Ln1Out"][0], &Ln1Out);
-  paddle::experimental::Tensor Dropout1Out;
+  paddle::Tensor Dropout1Out;
   egr::EagerUtils::GetOutput(outs["Dropout1Out"][0], &Dropout1Out);
-  paddle::experimental::Tensor Dropout2Out;
+  paddle::Tensor Dropout2Out;
   egr::EagerUtils::GetOutput(outs["Dropout2Out"][0], &Dropout2Out);
 
   {

paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_gate_attention_fwd_func.cc

@@ -19,27 +19,27 @@
 #include "paddle/fluid/eager/api/utils/global_utils.h"
 #include "paddle/fluid/platform/profiler/event_tracing.h"
 
-std::tuple<paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor,
-           paddle::experimental::Tensor>
+std::tuple<paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor,
+           paddle::Tensor>
 fused_gate_attention_dygraph_function(
-    const paddle::experimental::Tensor& Query,
-    const paddle::experimental::Tensor& Key,
-    const paddle::experimental::Tensor& QueryWeight,
-    const paddle::experimental::Tensor& KeyWeight,
-    const paddle::experimental::Tensor& ValueWeight,
-    const paddle::experimental::Tensor& QKVWeight,
-    const paddle::experimental::Tensor& NonbatchedBias,
-    const paddle::experimental::Tensor& SrcMask,
-    const paddle::experimental::Tensor& GateWeight,
-    const paddle::experimental::Tensor& GateBias,
-    const paddle::experimental::Tensor& OutLinearWeight,
-    const paddle::experimental::Tensor& OutLinearBias,
+    const paddle::Tensor& Query,
+    const paddle::Tensor& Key,
+    const paddle::Tensor& QueryWeight,
+    const paddle::Tensor& KeyWeight,
+    const paddle::Tensor& ValueWeight,
+    const paddle::Tensor& QKVWeight,
+    const paddle::Tensor& NonbatchedBias,
+    const paddle::Tensor& SrcMask,
+    const paddle::Tensor& GateWeight,
+    const paddle::Tensor& GateBias,
+    const paddle::Tensor& OutLinearWeight,
+    const paddle::Tensor& OutLinearBias,
     const paddle::framework::AttributeMap& attr_map) {
   paddle::platform::RecordEvent dygraph_entrance_record_event(
       "fused_gate_attention dygraph",
@@ -52,8 +52,7 @@ fused_gate_attention_dygraph_function(
       paddle::imperative::AmpLevel::O0) {
     VLOG(5) << "Check and Prepare For AMP";
 
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         egr::kSlotSmallVectorSize>
+    paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
         amp_tensors_vector = {
             {Query}, {SrcMask}, {OutLinearWeight}, {OutLinearBias}};
     if (Key.initialized()) amp_tensors_vector.push_back({Key});
@@ -247,21 +246,21 @@ fused_gate_attention_dygraph_function(
       true,
       {});
 
-  paddle::experimental::Tensor QueryTransposeOut;
+  paddle::Tensor QueryTransposeOut;
   egr::EagerUtils::GetOutput(outs["QueryTransposeOut"][0], &QueryTransposeOut);
-  paddle::experimental::Tensor KeyTransposeOut;
+  paddle::Tensor KeyTransposeOut;
   egr::EagerUtils::GetOutput(outs["KeyTransposeOut"][0], &KeyTransposeOut);
-  paddle::experimental::Tensor ValueTransposeOut;
+  paddle::Tensor ValueTransposeOut;
   egr::EagerUtils::GetOutput(outs["ValueTransposeOut"][0], &ValueTransposeOut);
-  paddle::experimental::Tensor QKVTransposeOut;
+  paddle::Tensor QKVTransposeOut;
   egr::EagerUtils::GetOutput(outs["QKVTransposeOut"][0], &QKVTransposeOut);
-  paddle::experimental::Tensor SoftmaxOut;
+  paddle::Tensor SoftmaxOut;
   egr::EagerUtils::GetOutput(outs["SoftmaxOut"][0], &SoftmaxOut);
-  paddle::experimental::Tensor FMHAOut;
+  paddle::Tensor FMHAOut;
   egr::EagerUtils::GetOutput(outs["FMHAOut"][0], &FMHAOut);
-  paddle::experimental::Tensor GateOut;
+  paddle::Tensor GateOut;
   egr::EagerUtils::GetOutput(outs["GateOut"][0], &GateOut);
-  paddle::experimental::Tensor Out;
+  paddle::Tensor Out;
   egr::EagerUtils::GetOutput(outs["Out"][0], &Out);
 
   {

paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_gemm_epilogue_fwd_func.cc

@@ -20,10 +20,10 @@
 #include "paddle/fluid/eager/api/utils/global_utils.h"
 #include "paddle/fluid/platform/profiler/event_tracing.h"
 
-paddle::experimental::Tensor fused_gemm_epilogue_dygraph_function(
-    const paddle::experimental::Tensor& X,
-    const paddle::experimental::Tensor& Y,
-    const paddle::experimental::Tensor& Bias,
+paddle::Tensor fused_gemm_epilogue_dygraph_function(
+    const paddle::Tensor& X,
+    const paddle::Tensor& Y,
+    const paddle::Tensor& Bias,
     const paddle::framework::AttributeMap& attr_map) {
   paddle::platform::RecordEvent dygraph_entrance_record_event(
       "fused_gemm_epilogue dygraph",
@@ -36,8 +36,7 @@ paddle::experimental::Tensor fused_gemm_epilogue_dygraph_function(
       paddle::imperative::AmpLevel::O0) {
     VLOG(5) << "Check and Prepare For AMP";
 
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         egr::kSlotSmallVectorSize>
+    paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
         amp_tensors_vector = {{X}, {Y}, {Bias}};
 
     auto amp_dst_dtype =
@@ -90,7 +89,7 @@ paddle::experimental::Tensor fused_gemm_epilogue_dygraph_function(
       true,
       {});
 
-  paddle::experimental::Tensor Out;
+  paddle::Tensor Out;
   egr::EagerUtils::GetOutput(outs["Out"][0], &Out);
 
   {

paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_attention_node.cc

@@ -20,20 +20,17 @@
 #include "paddle/fluid/imperative/tracer.h"
 #include "paddle/phi/api/all.h"
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     egr::kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
 fused_attentionGradNodeCompat::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    paddle::small_vector<std::vector<paddle::Tensor>,
                          egr::kSlotSmallVectorSize>& grads,
     bool create_graph,
     bool is_new_grad) {
   VLOG(3) << "Running Eager Backward Node: fused_attentionGradNodeCompat";
   const auto& out_metas = OutputMeta();
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       outputs(23);
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       hooked_grads0 = fused_attentionGradNodeCompat::ApplyGradientHooks(grads);
 
   bool pre_layer_norm = false;

paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_bias_dropout_residual_layer_norm_node.cc

@@ -20,21 +20,18 @@
 #include "paddle/fluid/imperative/tracer.h"
 #include "paddle/phi/api/all.h"
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     egr::kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
 fused_bias_dropout_residual_layer_normGradNodeCompat::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    paddle::small_vector<std::vector<paddle::Tensor>,
                          egr::kSlotSmallVectorSize>& grads,
     bool create_graph,
     bool is_new_grad) {
   const auto& out_metas = OutputMeta();
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       outputs(5);
   VLOG(3) << "Running Eager Backward Node: "
              "fused_bias_dropout_residual_layer_normGradNodeCompat";
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       hooked_grads0 = fused_bias_dropout_residual_layer_normGradNodeCompat::
           ApplyGradientHooks(grads);
   std::map<std::string, std::vector<std::shared_ptr<egr::EagerVariable>>> ins0 =

paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_feedforward_node.cc

@@ -20,21 +20,18 @@
 #include "paddle/fluid/imperative/tracer.h"
 #include "paddle/phi/api/all.h"
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     egr::kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
 fused_feedforwardGradNodeCompat::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    paddle::small_vector<std::vector<paddle::Tensor>,
                          egr::kSlotSmallVectorSize>& grads,
     bool create_graph,
     bool is_new_grad) {
   VLOG(3) << "Running Eager Backward Node: fused_feedforwardGradNodeCompat";
   const auto& out_metas = OutputMeta();
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       outputs(11);
 
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       hooked_grads0 =
           fused_feedforwardGradNodeCompat::ApplyGradientHooks(grads);
 

paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_gate_attention_node.cc

@@ -20,21 +20,18 @@
 #include "paddle/fluid/imperative/tracer.h"
 #include "paddle/phi/api/all.h"
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     egr::kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
 fused_gate_attentionGradNodeCompat::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    paddle::small_vector<std::vector<paddle::Tensor>,
                          egr::kSlotSmallVectorSize>& grads,
     bool create_graph,
     bool is_new_grad) {
   VLOG(3) << "Running Eager Backward Node: fused_gate_attentionGradNodeCompat";
 
   const auto& out_metas = OutputMeta();
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       outputs(12);
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       hooked_grads0 =
           fused_gate_attentionGradNodeCompat::ApplyGradientHooks(grads);
 

paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_gemm_epilogue_node.cc

@@ -20,20 +20,17 @@
 #include "paddle/fluid/imperative/tracer.h"
 #include "paddle/phi/api/all.h"
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     egr::kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
 fused_gemm_epilogueGradNodeCompat::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    paddle::small_vector<std::vector<paddle::Tensor>,
                          egr::kSlotSmallVectorSize>& grads,
     bool create_graph,
     bool is_new_grad) {
   const auto& out_metas = OutputMeta();
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       outputs(3);
   VLOG(3) << "Running Eager Backward Node: fused_gemm_epilogueGradNodeCompat";
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       hooked_grads0 =
           fused_gemm_epilogueGradNodeCompat::ApplyGradientHooks(grads);
   std::map<std::string, std::vector<std::shared_ptr<egr::EagerVariable>>> ins0 =

paddle/fluid/eager/api/utils/hook_utils.cc

@@ -24,9 +24,8 @@ namespace egr {
 namespace egr_utils_api {
 
 int64_t RegisterGradientHookForTensor(
-    const paddle::experimental::Tensor& tensor,
-    const std::function<paddle::experimental::Tensor(
-        const paddle::experimental::Tensor&)>& hook) {
+    const paddle::Tensor& tensor,
+    const std::function<paddle::Tensor(const paddle::Tensor&)>& hook) {
   // Find grad_node and out_rank from AutogradMeta
   std::shared_ptr<GradNodeBase> grad_node = EagerUtils::grad_node(tensor);
   auto rank_info = EagerUtils::unsafe_autograd_meta(tensor)->OutRankInfo();
@@ -37,7 +36,7 @@ int64_t RegisterGradientHookForTensor(
       std::move(std::make_shared<CppTensorHook>(hook)));
 }
 
-void RegisterReduceHookForTensor(const paddle::experimental::Tensor& tensor,
+void RegisterReduceHookForTensor(const paddle::Tensor& tensor,
                                  const std::function<void()>& hook) {
   if (IsLeafTensor(tensor)) {
     VLOG(6) << "Register ReduceHook for leaf tensor";
@@ -57,7 +56,7 @@ void RegisterReduceHookForTensor(const paddle::experimental::Tensor& tensor,
   }
 }
 
-void RetainGradForTensor(const paddle::experimental::Tensor& tensor) {
+void RetainGradForTensor(const paddle::Tensor& tensor) {
   if (IsLeafTensor(tensor)) {
     // Leaf tensor's grad will always be retained
     // Refer to implementation of AccumulationNode for more details
@@ -70,11 +69,10 @@ void RetainGradForTensor(const paddle::experimental::Tensor& tensor) {
       meta->SetRetainGrads(true);
     }
 
-    std::weak_ptr<paddle::experimental::Tensor> weak_grad_tensor =
-        meta->WeakGrad();
+    std::weak_ptr<paddle::Tensor> weak_grad_tensor = meta->WeakGrad();
 
     // Define Hook
-    auto hook = [weak_grad_tensor](const paddle::experimental::Tensor& t) {
+    auto hook = [weak_grad_tensor](const paddle::Tensor& t) {
       if (!weak_grad_tensor.expired()) {
         auto grad_tensor = weak_grad_tensor.lock();
         if (t.defined()) {
@@ -84,12 +82,12 @@ void RetainGradForTensor(const paddle::experimental::Tensor& tensor) {
           grad_tensor->set_autograd_meta(t.mutable_autograd_meta());
           return *grad_tensor.get();
         } else {
-          VLOG(7) << "Retain NULL paddle::experimental::Tensor in Grad Hook";
-          return paddle::experimental::Tensor();
+          VLOG(7) << "Retain NULL paddle::Tensor in Grad Hook";
+          return paddle::Tensor();
         }
       } else {
-        VLOG(7) << "Retain NULL paddle::experimental::Tensor in Grad Hook";
-        return paddle::experimental::Tensor();
+        VLOG(7) << "Retain NULL paddle::Tensor in Grad Hook";
+        return paddle::Tensor();
       }
     };
 

paddle/fluid/eager/api/utils/hook_utils.h

@@ -22,13 +22,12 @@ namespace egr {
 namespace egr_utils_api {
 
 int64_t RegisterGradientHookForTensor(
-    const paddle::experimental::Tensor& tensor,
-    const std::function<paddle::experimental::Tensor(
-        const paddle::experimental::Tensor&)>& hook);
+    const paddle::Tensor& tensor,
+    const std::function<paddle::Tensor(const paddle::Tensor&)>& hook);
 
-void RegisterReduceHookForTensor(const paddle::experimental::Tensor& tensor,
+void RegisterReduceHookForTensor(const paddle::Tensor& tensor,
                                  const std::function<void()>& hook);
-void RetainGradForTensor(const paddle::experimental::Tensor& tensor);
+void RetainGradForTensor(const paddle::Tensor& tensor);
 
 void RegisterBackwardFinalHook(const std::function<void()>& hook);
 

paddle/fluid/eager/api/utils/tensor_utils.cc

@@ -27,7 +27,7 @@
 namespace egr {
 namespace egr_utils_api {
 
-bool IsLeafTensor(const paddle::experimental::Tensor& target) {
+bool IsLeafTensor(const paddle::Tensor& target) {
   std::shared_ptr<GradNodeBase> grad_node = EagerUtils::grad_node(target);
   if (!grad_node ||
       std::dynamic_pointer_cast<GradNodeAccumulation>(grad_node)) {
@@ -37,14 +37,13 @@ bool IsLeafTensor(const paddle::experimental::Tensor& target) {
   return false;
 }
 
-paddle::experimental::Tensor CreateTensorWithValue(
-    const phi::DDim& ddim,
-    const paddle::platform::Place& place,
-    const phi::DataType& dtype,
-    const phi::DataLayout& layout,
-    float value,
-    bool is_leaf) {
-  paddle::experimental::Tensor out = paddle::experimental::full(
+paddle::Tensor CreateTensorWithValue(const phi::DDim& ddim,
+                                     const paddle::platform::Place& place,
+                                     const phi::DataType& dtype,
+                                     const phi::DataLayout& layout,
+                                     float value,
+                                     bool is_leaf) {
+  paddle::Tensor out = paddle::experimental::full(
       phi::vectorize(ddim), paddle::experimental::Scalar(value), dtype, place);
 
   auto meta = EagerUtils::autograd_meta(&out);

paddle/fluid/eager/api/utils/tensor_utils.h

@@ -22,15 +22,14 @@ namespace egr_utils_api {
 
 // If and only if the tensor holds an AccumulationNode
 // Then it's treated as a leaf tensor
-bool IsLeafTensor(const paddle::experimental::Tensor& target);
+bool IsLeafTensor(const paddle::Tensor& target);
 
-paddle::experimental::Tensor CreateTensorWithValue(
-    const phi::DDim& ddim,
-    const paddle::platform::Place& place,
-    const phi::DataType& dtype,
-    const phi::DataLayout& layout,
-    float value,
-    bool is_leaf = true);
+paddle::Tensor CreateTensorWithValue(const phi::DDim& ddim,
+                                     const paddle::platform::Place& place,
+                                     const phi::DataType& dtype,
+                                     const phi::DataLayout& layout,
+                                     float value,
+                                     bool is_leaf = true);
 
 }  // namespace egr_utils_api
 }  // namespace egr

paddle/fluid/eager/auto_code_generator/eager_generator.cc

@@ -1438,10 +1438,10 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
   Controller.Instance().GetExpectedPlace(), {});
 
         // According to fwd_outputs_names
-        std::vector<paddle::experimental::Tensor> Out0 =
+        std::vector<paddle::Tensor> Out0 =
   GetOutputs(outs["Out0"]);
-        paddle::experimental::Tensor Out1 = GetOutputs(outs["Out1"][0]);
-        std::vector<paddle::experimental::Tensor> Out2 =
+        paddle::Tensor Out1 = GetOutputs(outs["Out1"][0]);
+        std::vector<paddle::Tensor> Out2 =
   GetOutputs(outs["Out2"]);
 
         // Grad Node Generation Codes
@@ -1480,7 +1480,7 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
 
     if (input.duplicable()) {
       const char* FWD_INS_ARG_TEMPLATE =
-          "const std::vector<paddle::experimental::Tensor>& %s";
+          "const std::vector<paddle::Tensor>& %s";
       input_args_str_list[input_position] = paddle::string::Sprintf(
           FWD_INS_ARG_TEMPLATE, LegalizeVarName(input_name));
       amp_function_call_args_str_list[input_position] =
@@ -1495,13 +1495,13 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
         for (auto& inplace_pair : forward_inplace_map) {
           if (inplace_pair.second == input_name) {
             flag_find_input_name = true;
-            FWD_INS_ARG_TEMPLATE = "paddle::experimental::Tensor& %s";
+            FWD_INS_ARG_TEMPLATE = "paddle::Tensor& %s";
             break;
           }
         }
       }
       if (!flag_find_input_name) {
-        FWD_INS_ARG_TEMPLATE = "const paddle::experimental::Tensor& %s";
+        FWD_INS_ARG_TEMPLATE = "const paddle::Tensor& %s";
       }
       input_args_str_list[input_position] = paddle::string::Sprintf(
           FWD_INS_ARG_TEMPLATE, LegalizeVarName(input_name));
@@ -1645,8 +1645,7 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
       // argument(EagerVariable*/vector<EagerVariable*>&),
       // in form of shared_ptr<EagerVariable>/vector<shared_ptr<EagerVariable>>
       if (output.duplicable()) {
-        const char* FWD_NUM_ARG_TEMPLATE =
-            ", std::vector<paddle::experimental::Tensor*>& %s";
+        const char* FWD_NUM_ARG_TEMPLATE = ", std::vector<paddle::Tensor*>& %s";
         std::string arg_str = paddle::string::Sprintf(
             FWD_NUM_ARG_TEMPLATE, LegalizeVarName(output_var_name));
         dygraph_function_args_str += arg_str;
@@ -1654,7 +1653,7 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
 
         core_ops_legacy_args_type_info[op_type].push_back("list");
       } else {
-        const char* FWD_NUM_ARG_TEMPLATE = ", paddle::experimental::Tensor* %s";
+        const char* FWD_NUM_ARG_TEMPLATE = ", paddle::Tensor* %s";
         std::string arg_str = paddle::string::Sprintf(
             FWD_NUM_ARG_TEMPLATE, LegalizeVarName(output_var_name));
         dygraph_function_args_str += arg_str;
@@ -1742,7 +1741,7 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
     std::string amp_logic_str = "";
     if (in_vars.size() != 0) {
       const char* AMP_TENSORS_VECTOR_TEMPLATE =
-          "    paddle::small_vector<std::vector<paddle::experimental::Tensor>, "
+          "    paddle::small_vector<std::vector<paddle::Tensor>, "
           "egr::kSlotSmallVectorSize> "
           "amp_tensors_vector = { "
           "%s };\n";
@@ -1897,7 +1896,7 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
       if (op_passing_outs_map[op_type].count(output_name)) {
         if (output.dispensable()) {
           const char* FWD_OUT_TENSORS_TEMPLATE =
-              "  std::vector<paddle::experimental::Tensor> %s;\n"
+              "  std::vector<paddle::Tensor> %s;\n"
               "  if (outs.count(\"%s\"))  "
               "egr::EagerUtils::GetOutputs(outs[\"%s\"], %s);\n"
               "  egr::EagerUtils::Output2Result(%s, &%s);\n";
@@ -1910,7 +1909,7 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
                                                    output_varname);
         } else {
           const char* FWD_OUT_TENSORS_TEMPLATE =
-              "  std::vector<paddle::experimental::Tensor> %s;\n"
+              "  std::vector<paddle::Tensor> %s;\n"
               "  egr::EagerUtils::GetOutputs(outs[\"%s\"], %s);\n"
               "  egr::EagerUtils::Output2Result(%s, &%s);\n";
           out_tensor_str = paddle::string::Sprintf(FWD_OUT_TENSORS_TEMPLATE,
@@ -1922,22 +1921,21 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
         }
       } else {
         const char* FWD_OUT_TENSORS_TEMPLATE =
-            "  std::vector<paddle::experimental::Tensor> %s;\n"
+            "  std::vector<paddle::Tensor> %s;\n"
             "  egr::EagerUtils::GetOutputs(outs[\"%s\"], &%s);\n";
         out_tensor_str = paddle::string::Sprintf(FWD_OUT_TENSORS_TEMPLATE,
                                                  output_varname,
                                                  output_name,
                                                  output_varname);
       }
-      return_types[return_position] =
-          "std::vector<paddle::experimental::Tensor>";
+      return_types[return_position] = "std::vector<paddle::Tensor>";
     } else {
       if (op_passing_outs_map[op_type].count(output_name)) {
         if (output.dispensable()) {
           const char* FWD_OUT_TENSOR_TEMPLATE =
               "  if (outs.count(\"%s\"))  "
               "egr::EagerUtils::GetOutput(outs[\"%s\"][0], %s);\n"
-              "  paddle::experimental::Tensor& %s = *%s;\n";
+              "  paddle::Tensor& %s = *%s;\n";
           out_tensor_str = paddle::string::Sprintf(FWD_OUT_TENSOR_TEMPLATE,
                                                    output_name,
                                                    output_name,
@@ -1947,7 +1945,7 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
         } else {
           const char* FWD_OUT_TENSOR_TEMPLATE =
               "  egr::EagerUtils::GetOutput(outs[\"%s\"][0], %s);\n"
-              "  paddle::experimental::Tensor& %s = *%s;\n";
+              "  paddle::Tensor& %s = *%s;\n";
           out_tensor_str = paddle::string::Sprintf(FWD_OUT_TENSOR_TEMPLATE,
                                                    output_name,
                                                    output_var_args_name,
@@ -1973,7 +1971,7 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
                                       LegalizeVarName(inplace_input_name));
         } else {
           const char* FWD_OUT_TENSOR_TEMPLATE =
-              "  paddle::experimental::Tensor %s;\n"
+              "  paddle::Tensor %s;\n"
               "  egr::EagerUtils::GetOutput(outs[\"%s\"][0], &%s);\n";
           out_tensor_str = paddle::string::Sprintf(FWD_OUT_TENSOR_TEMPLATE,
                                                    output_varname,
@@ -1981,7 +1979,7 @@ static std::pair<std::string, std::string> GenerateForwardFunctionContents(
                                                    output_varname);
         }
       }
-      return_types[return_position] = "paddle::experimental::Tensor";
+      return_types[return_position] = "paddle::Tensor";
     }
 
     if (!forward_inplace_map.empty() &&
@@ -2160,7 +2158,7 @@ static std::string GenerateSingleOpBase(
   }
   generated_grad_function_body += fill_zero_str;
   generated_grad_function_body +=
-      "  paddle::small_vector<std::vector<paddle::experimental::Tensor>, "
+      "  paddle::small_vector<std::vector<paddle::Tensor>, "
       "egr::kSlotSmallVectorSize> " +
       hooked_grads + " = " + fwd_op_type +
       "GradNodeCompat::ApplyGradientHooks(grads);\n";
@@ -2675,7 +2673,7 @@ static std::string GenerateGradNodeCCContents(
             egr::Controller::Instance().ExpectedPlace(), false, {});
     }
 
-    vector<vector<paddle::experimental::Tensor>> outputs(outs.size());
+    vector<vector<paddle::Tensor>> outputs(outs.size());
     for(auto& kv : outs) {
         outputs["fwd_inputs_name_pos_map[grad_outs_slotname_map[kv.first]]"] =
   GetOutputs(outs["kv.first"]);
@@ -2751,7 +2749,7 @@ static std::string GenerateGradNodeCCContents(
 
   const char* BWD_RETURN_TEMPLATE =
       "  const auto& out_metas = OutputMeta();\n"
-      "  paddle::small_vector<std::vector<paddle::experimental::Tensor>, "
+      "  paddle::small_vector<std::vector<paddle::Tensor>, "
       "egr::kSlotSmallVectorSize> outputs(%d);\n"
       "%s\n"
       "  if(NeedComplexToRealConversion()) "
@@ -2762,10 +2760,10 @@ static std::string GenerateGradNodeCCContents(
 
   // [Generation] Get Full Grad Function
   const char* GRAD_FUNCTION_TEMPLATE =
-      "paddle::small_vector<std::vector<paddle::experimental::Tensor>, "
+      "paddle::small_vector<std::vector<paddle::Tensor>, "
       "egr::kSlotSmallVectorSize> "
       "%sGradNodeCompat::operator()("
-      "paddle::small_vector<std::vector<paddle::experimental::Tensor>, "
+      "paddle::small_vector<std::vector<paddle::Tensor>, "
       "egr::kSlotSmallVectorSize>& grads, bool "
       "create_graph, bool is_new_grad) {\n"
       "%s"
@@ -2804,10 +2802,10 @@ static std::string GenerateGradNodeHeaderContents(
       "%sGradNodeCompat \"; }\n"
       "\n"
       "  virtual "
-      "paddle::small_vector<std::vector<paddle::experimental::Tensor>, "
+      "paddle::small_vector<std::vector<paddle::Tensor>, "
       "egr::kSlotSmallVectorSize> "
       "operator()("
-      "paddle::small_vector<std::vector<paddle::experimental::Tensor>, "
+      "paddle::small_vector<std::vector<paddle::Tensor>, "
       "egr::kSlotSmallVectorSize>& grads, bool "
       "create_graph = false, bool is_new_grad = false) "
       "override;\n"
@@ -2883,7 +2881,7 @@ static std::string GenerateGradNodeHeaderContents(
       }
       if (duplicable_tensors.count(tensor_wrapper_name)) {
         const char* ATTR_TENSOR_WRAPPER_ARG_TEMPLATE =
-            "const std::vector<paddle::experimental::Tensor>& %s";
+            "const std::vector<paddle::Tensor>& %s";
         tensor_wrapper_arg_str = paddle::string::Sprintf(
             ATTR_TENSOR_WRAPPER_ARG_TEMPLATE, tensor_wrapper_name);
 
@@ -2912,7 +2910,7 @@ static std::string GenerateGradNodeHeaderContents(
 
       } else {
         const char* ATTR_TENSOR_WRAPPER_ARG_TEMPLATE =
-            "const paddle::experimental::Tensor& %s";
+            "const paddle::Tensor& %s";
         tensor_wrapper_arg_str = paddle::string::Sprintf(
             ATTR_TENSOR_WRAPPER_ARG_TEMPLATE, tensor_wrapper_name);
 

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

@@ -81,12 +81,12 @@ def ParseArguments():
 ######################
 # Code Gen Templates #
 ######################
-SET_PLAIN_TENSOR_WRAPPER_TEMPLATE = """  void SetTensorWrapper{}(const paddle::experimental::Tensor& {}) {{
+SET_PLAIN_TENSOR_WRAPPER_TEMPLATE = """  void SetTensorWrapper{}(const paddle::Tensor& {}) {{
     {} = egr::TensorWrapper({}, {});
   }}
 """
 
-SET_VECTOR_TENSOR_WRAPPER_TEMPLATE = """  void SetTensorWrapper{}(const std::vector<paddle::experimental::Tensor>& {}) {{
+SET_VECTOR_TENSOR_WRAPPER_TEMPLATE = """  void SetTensorWrapper{}(const std::vector<paddle::Tensor>& {}) {{
     for(const auto& eager_tensor : {}) {{
       {}.emplace_back(egr::TensorWrapper(eager_tensor, {}));
     }};
@@ -126,8 +126,8 @@ class {} : public egr::GradNodeBase {{
       egr::GradNodeBase(bwd_in_slot_num, bwd_out_slot_num) {{}}
   ~{}() override = default;
 
-  virtual paddle::small_vector<std::vector<paddle::experimental::Tensor>, egr::kSlotSmallVectorSize> operator()(
-      paddle::small_vector<std::vector<paddle::experimental::Tensor>, egr::kSlotSmallVectorSize>& grads, bool create_graph = false, bool is_new_grad = false) override;
+  virtual paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize> operator()(
+      paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>& grads, bool create_graph = false, bool is_new_grad = false) override;
   std::string name() override {{ return \"{}\"; }}
 
   void ClearTensorWrappers() override {{
@@ -152,7 +152,7 @@ class {} : public egr::GradNodeBase {{
 """
 
 GRAD_FUNCTION_TEMPLATE = """
-paddle::small_vector<std::vector<paddle::experimental::Tensor>, egr::kSlotSmallVectorSize> {}::operator()(paddle::small_vector<std::vector<paddle::experimental::Tensor>, egr::kSlotSmallVectorSize>& grads, bool create_graph, bool is_new_grad) {{
+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
 {}
@@ -419,7 +419,7 @@ BUMP_INPLACE_VERSION_TEMPLATE = """
 AMP_LOGIC_TEMPLATE = """  if (egr::Controller::Instance().GetAMPLevel() != paddle::imperative::AmpLevel::O0) {{
     VLOG(5) << "Check and Prepare For AMP";
     {}
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>, egr::kSlotSmallVectorSize> amp_tensors_vector = {};
+    paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize> amp_tensors_vector = {};
     {}
     {}
     {}
@@ -431,7 +431,7 @@ AMP_LOGIC_TEMPLATE = """  if (egr::Controller::Instance().GetAMPLevel() != paddl
 """
 LAYOUT_LOGIC_TEMPLATE = """
   if (egr::Controller::Instance().UseLayoutAutoTune()) {{
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>, egr::kSlotSmallVectorSize> tensors_vector = {};
+    paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize> tensors_vector = {};
     {}
     {}
     VLOG(5) << "Check and Prepare For LAYOUT "<< op_name;
@@ -443,18 +443,18 @@ LAYOUT_LOGIC_TEMPLATE = """
   }}
 """
 CREATE_PLAIN_OPTIONAL_TENSOR_TEMPLATE = """
-  paddle::optional<paddle::experimental::Tensor> {}_optional;
-  if({}.initialized()) {}_optional = paddle::make_optional<paddle::experimental::Tensor>({});
+  paddle::optional<paddle::Tensor> {}_optional;
+  if({}.initialized()) {}_optional = paddle::make_optional<paddle::Tensor>({});
 """
 
 CREATE_RECOVER_OPTIONAL_TENSOR_TEMPLATE = """
-  paddle::optional<paddle::experimental::Tensor> {}_optional;
-  if( {}.impl() ) {}_optional = paddle::make_optional<paddle::experimental::Tensor>({});
+  paddle::optional<paddle::Tensor> {}_optional;
+  if( {}.impl() ) {}_optional = paddle::make_optional<paddle::Tensor>({});
 """
 
 CREATE_RECOVER_OPTIONAL_VECTOR_TENSOR_TEMPLATE = """
-  paddle::optional<std::vector<paddle::experimental::Tensor>> {}_optional;
-  if( !{}.empty() ) {}_optional = paddle::make_optional<std::vector<paddle::experimental::Tensor>>({});
+  paddle::optional<std::vector<paddle::Tensor>> {}_optional;
+  if( !{}.empty() ) {}_optional = paddle::make_optional<std::vector<paddle::Tensor>>({});
 """
 
 CHECK_BACKWARD_INPLACE_TEMPLATE = """
@@ -470,8 +470,8 @@ CHECK_NAN_AND_INF_TEMPLATE = """  if (FLAGS_check_nan_inf) {{ egr::CheckTensorHa
 """
 
 inplace_optional_out_type_map = {
-    "Tensor": "paddle::optional<paddle::experimental::Tensor>&",
-    "std::vector<Tensor>": "paddle::optional<std::vector<paddle::experimental::Tensor>>&",
+    "Tensor": "paddle::optional<paddle::Tensor>&",
+    "std::vector<Tensor>": "paddle::optional<std::vector<paddle::Tensor>>&",
 }
 
 
@@ -1282,9 +1282,11 @@ class DygraphForwardFunctionGenerator(DygraphFunctionGeneratorBase):
                         and forward_inplace_map
                         and name in forward_inplace_map.keys()
                     ):
-                        arg_str = f"paddle::optional<paddle::experimental::Tensor>& {name}"
+                        arg_str = f"paddle::optional<paddle::Tensor>& {name}"
                     else:
-                        arg_str = f"const paddle::optional<paddle::experimental::Tensor>& {name}"
+                        arg_str = (
+                            f"const paddle::optional<paddle::Tensor>& {name}"
+                        )
                     amp_tensors_vector_optional_list.append(
                         f"if ({name}) amp_tensors_vector.push_back({{ *{name} }});\n"
                     )
@@ -1303,13 +1305,13 @@ class DygraphForwardFunctionGenerator(DygraphFunctionGeneratorBase):
                         and forward_inplace_map
                         and name in forward_inplace_map.keys()
                     ):
-                        arg_str = f"paddle::experimental::Tensor& {name}"
+                        arg_str = f"paddle::Tensor& {name}"
                         amp_tensors_vector_list.append(f"{{{name}}}")
                         amp_autocast_list.append(
                             f"auto new_{name} = egr::EagerAmpAutoCast(\"{name}\", {name}, amp_dst_dtype, op_name);\n"
                         )
                     else:
-                        arg_str = f"const paddle::experimental::Tensor& {name}"
+                        arg_str = f"const paddle::Tensor& {name}"
                         amp_tensors_vector_list.append(f"{{{name}}}")
                         amp_autocast_list.append(
                             f"auto new_{name} = egr::EagerAmpAutoCast(\"{name}\", {name}, amp_dst_dtype, op_name);\n"
@@ -1326,9 +1328,9 @@ class DygraphForwardFunctionGenerator(DygraphFunctionGeneratorBase):
                         and forward_inplace_map
                         and name in forward_inplace_map.keys()
                     ):
-                        arg_str = f"paddle::optional<std::vector<paddle::experimental::Tensor>>& {name}"
+                        arg_str = f"paddle::optional<std::vector<paddle::Tensor>>& {name}"
                     else:
-                        arg_str = f"const paddle::optional<std::vector<paddle::experimental::Tensor>>& {name}"
+                        arg_str = f"const paddle::optional<std::vector<paddle::Tensor>>& {name}"
                     amp_tensors_vector_optional_list.append(
                         f"if ({name}) amp_tensors_vector.push_back( *{name} );\n"
                     )
@@ -1344,11 +1346,9 @@ class DygraphForwardFunctionGenerator(DygraphFunctionGeneratorBase):
                         and forward_inplace_map
                         and name in forward_inplace_map.keys()
                     ):
-                        arg_str = (
-                            f"std::vector<paddle::experimental::Tensor>& {name}"
-                        )
+                        arg_str = f"std::vector<paddle::Tensor>& {name}"
                     else:
-                        arg_str = f"const std::vector<paddle::experimental::Tensor>& {name}"
+                        arg_str = f"const std::vector<paddle::Tensor>& {name}"
                     amp_tensors_vector_list.append(f"{name}")
                     amp_autocast_list.append(
                         f"auto new_{name} = egr::EagerAmpAutoCasts(\"{name}\", {name}, amp_dst_dtype, op_name);\n"
@@ -1432,9 +1432,9 @@ class DygraphForwardFunctionGenerator(DygraphFunctionGeneratorBase):
                             rtype
                         ]
                     else:
-                        returns_type_list[pos] = "paddle::experimental::Tensor&"
+                        returns_type_list[pos] = "paddle::Tensor&"
                 else:
-                    returns_type_list[pos] = "paddle::experimental::Tensor"
+                    returns_type_list[pos] = "paddle::Tensor"
             else:
                 assert IsVectorTensorType(rtype)
                 if (
@@ -1451,13 +1451,9 @@ class DygraphForwardFunctionGenerator(DygraphFunctionGeneratorBase):
                             rtype
                         ]
                     else:
-                        returns_type_list[
-                            pos
-                        ] = "std::vector<paddle::experimental::Tensor>&"
+                        returns_type_list[pos] = "std::vector<paddle::Tensor>&"
                 else:
-                    returns_type_list[
-                        pos
-                    ] = "std::vector<paddle::experimental::Tensor>"
+                    returns_type_list[pos] = "std::vector<paddle::Tensor>"
 
         if num_outputs == 1:
             returns_str = returns_list[0]
@@ -2163,7 +2159,7 @@ class DygraphNodeGenerator(DygraphFunctionGeneratorBase):
         composite_grad_api_namespace = f"paddle::prim::{namespace}"
         grad_function_prepare_str = f"""
   const auto& out_metas = OutputMeta();
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>, egr::kSlotSmallVectorSize> returns({slot_num_bwd_outputs});
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize> returns({slot_num_bwd_outputs});
   for (int i = 0; i < {slot_num_bwd_outputs}; ++i) {{
     out_metas[i].size() == 0 ? returns[i].resize(1) : returns[i].resize(out_metas[i].size());
   }}
@@ -2221,7 +2217,7 @@ class DygraphNodeGenerator(DygraphFunctionGeneratorBase):
             else:
                 assert IsVectorTensorType(ttype)
                 grad_function_prepare_str += f"""
-  std::vector<paddle::experimental::Tensor*> api_output_{out_index};
+  std::vector<paddle::Tensor*> api_output_{out_index};
   api_output_{out_index}.reserve(returns[{fwd_position}].size());
   for (size_t i = 0; i < returns[{fwd_position}].size(); ++i) {{
     if (out_metas[{fwd_position}].empty() || out_metas[{fwd_position}][i].IsStopGradient()) {{
@@ -2233,7 +2229,7 @@ class DygraphNodeGenerator(DygraphFunctionGeneratorBase):
 
         grad_api_args_str = ", ".join(grad_api_args)
         composite_grad_api_args_str = ", ".join(grad_api_args)
-        composite_template_name = "<paddle::experimental::Tensor>"
+        composite_template_name = "<paddle::Tensor>"
 
         if is_invoke_forward_api:
             autograd_api_out = "auto"

paddle/fluid/eager/autograd_meta.h

@@ -18,7 +18,7 @@
 #include "paddle/fluid/eager/grad_node_info.h"
 namespace egr {
 
-using AbstractAutogradMeta = paddle::experimental::AbstractAutogradMeta;
+using AbstractAutogradMeta = paddle::AbstractAutogradMeta;
 /**
  *
  * AutogradMeta is what record the backward info for tensor. When we run
@@ -68,7 +68,7 @@ class AutogradMeta : public AbstractAutogradMeta {
 
   ~AutogradMeta() override = default;
 
-  const paddle::experimental::Tensor& Grad() const {
+  const paddle::Tensor& Grad() const {
     PADDLE_ENFORCE_NOT_NULL(
         grad_.get(),
         paddle::platform::errors::InvalidArgument(
@@ -79,9 +79,9 @@ class AutogradMeta : public AbstractAutogradMeta {
     return *(grad_.get());
   }
 
-  paddle::experimental::Tensor* MutableGrad() { return grad_.get(); }
+  paddle::Tensor* MutableGrad() { return grad_.get(); }
 
-  std::weak_ptr<paddle::experimental::Tensor> WeakGrad() { return grad_; }
+  std::weak_ptr<paddle::Tensor> WeakGrad() { return grad_; }
 
   void SetGradNode(const std::shared_ptr<GradNodeBase>& grad_node) {
     PADDLE_ENFORCE_NOT_NULL(
@@ -133,8 +133,7 @@ class AutogradMeta : public AbstractAutogradMeta {
 
  private:
   // TODO(jiabin) :Should we use pointer instead of object?
-  std::shared_ptr<paddle::experimental::Tensor> grad_{
-      std::make_shared<paddle::experimental::Tensor>()};
+  std::shared_ptr<paddle::Tensor> grad_{std::make_shared<paddle::Tensor>()};
 
   // GradNodeBase is base class of all grad op which is a
   // wrapper for grad op. This class will make grad op easy

paddle/fluid/eager/backward.cc

@@ -82,8 +82,7 @@ void EnforceGradNodeHasInput(GradNodeBase* node) {
           node->name()));
 }
 
-void DuplicateCheck(const std::vector<paddle::experimental::Tensor>& inputs,
-                    bool is_input) {
+void DuplicateCheck(const std::vector<paddle::Tensor>& inputs, bool is_input) {
   std::unordered_set<AutogradMeta*> visisted_ins;
   std::string msg = is_input ? "inputs" : "outputs";
   for (auto in : inputs) {
@@ -102,14 +101,14 @@ void DuplicateCheck(const std::vector<paddle::experimental::Tensor>& inputs,
 
 GeneralGrad* GeneralGrad::general_grad_ = new GeneralGrad();
 
-std::vector<paddle::experimental::Tensor> RunBackward(
-    const std::vector<paddle::experimental::Tensor>& tensors,  // output
-    const std::vector<paddle::experimental::Tensor>& grad_tensors,
+std::vector<paddle::Tensor> RunBackward(
+    const std::vector<paddle::Tensor>& tensors,  // output
+    const std::vector<paddle::Tensor>& grad_tensors,
     bool retain_graph,
     bool create_graph = false,
-    const std::vector<paddle::experimental::Tensor>& inputs = {},
+    const std::vector<paddle::Tensor>& inputs = {},
     bool allow_unused = false,
-    const std::vector<paddle::experimental::Tensor>& no_grad_vars = {}) {
+    const std::vector<paddle::Tensor>& no_grad_vars = {}) {
   VLOG(3) << "Start Backward";
 
   // *Gradient Hook should happen at node-level
@@ -128,7 +127,7 @@ std::vector<paddle::experimental::Tensor> RunBackward(
   std::unordered_map<GradNodeBase*, std::unique_ptr<GradTensorHolder>>
       node_input_buffers_dict;
   for (size_t i = 0; i < tensors.size(); i++) {
-    const paddle::experimental::Tensor& tensor = tensors[i];
+    const paddle::Tensor& tensor = tensors[i];
 
     AutogradMeta* auto_grad_meta = EagerUtils::nullable_autograd_meta(tensor);
     if (auto_grad_meta == nullptr) {
@@ -255,8 +254,7 @@ std::vector<paddle::experimental::Tensor> RunBackward(
 
     VLOG(7) << "Run Backward Kernel with GradTensorHolder.";
     // Run Pre Backward Node and get outputs
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         kSlotSmallVectorSize>
+    paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
         grad_output_tensors = (*node)(
             node_input_buffer->Buffers(), create_graph, is_general_grad);
 
@@ -315,8 +313,7 @@ std::vector<paddle::experimental::Tensor> RunBackward(
                 "grad_output_tensors[i].size(), which is: %d. This error may "
                 "indicate autoprune or autograd api error. ",
                 grad_output_tensors.size()));
-        paddle::experimental::Tensor& grad_output_tensor =
-            grad_output_tensors[i][j];
+        paddle::Tensor& grad_output_tensor = grad_output_tensors[i][j];
 
         if ((!grad_output_tensor.defined() ||
              !grad_output_tensor.initialized())) {
@@ -380,10 +377,9 @@ std::vector<paddle::experimental::Tensor> RunBackward(
   return GeneralGrad::Instance().GetResults(inputs, allow_unused, create_graph);
 }
 
-void Backward(
-    const std::vector<paddle::experimental::Tensor>& tensors,  // outputs
-    const std::vector<paddle::experimental::Tensor>& grad_tensors,
-    bool retain_graph) {
+void Backward(const std::vector<paddle::Tensor>& tensors,  // outputs
+              const std::vector<paddle::Tensor>& grad_tensors,
+              bool retain_graph) {
   VLOG(3) << "Run in Backward";
   paddle::platform::RecordEvent backward_record_event(
       "backward", paddle::platform::TracerEventType::UserDefined, 1);
@@ -391,15 +387,15 @@ void Backward(
   phi::autotune::AutoTuneStatus::Instance().Update();
 }
 
-std::vector<paddle::experimental::Tensor> Grad(
-    const std::vector<paddle::experimental::Tensor>& tensors,  // outputs
-    const std::vector<paddle::experimental::Tensor>& inputs,
-    const std::vector<paddle::experimental::Tensor>& grad_tensors,
+std::vector<paddle::Tensor> Grad(
+    const std::vector<paddle::Tensor>& tensors,  // outputs
+    const std::vector<paddle::Tensor>& inputs,
+    const std::vector<paddle::Tensor>& grad_tensors,
     bool retain_graph,
     bool create_graph,
     bool only_inputs,
     bool allow_unused,
-    const std::vector<paddle::experimental::Tensor>& no_grad_vars) {
+    const std::vector<paddle::Tensor>& no_grad_vars) {
   VLOG(3) << "Run in Grad";
 
   DuplicateCheck(inputs, true /* is_input */);

paddle/fluid/eager/backward.h

@@ -22,19 +22,19 @@ namespace egr {
 // Backward():
 // tensors corresponds to those lived in the backward graph
 // each grad_tensors[i] keeps the value for its corresponding tensors[i]
-void Backward(const std::vector<paddle::experimental::Tensor>& tensors,
-              const std::vector<paddle::experimental::Tensor>& grad_tensors,
+void Backward(const std::vector<paddle::Tensor>& tensors,
+              const std::vector<paddle::Tensor>& grad_tensors,
               bool retain_graph = false);
 
-std::vector<paddle::experimental::Tensor> Grad(
-    const std::vector<paddle::experimental::Tensor>& tensors,
-    const std::vector<paddle::experimental::Tensor>& inputs,
-    const std::vector<paddle::experimental::Tensor>& grad_tensors = {},
+std::vector<paddle::Tensor> Grad(
+    const std::vector<paddle::Tensor>& tensors,
+    const std::vector<paddle::Tensor>& inputs,
+    const std::vector<paddle::Tensor>& grad_tensors = {},
     bool retain_graph = false,
     bool create_graph = false,
     bool only_inputs = false,
     bool allow_unused = false,
-    const std::vector<paddle::experimental::Tensor>& no_grad_vars = {});
+    const std::vector<paddle::Tensor>& no_grad_vars = {});
 
 // Reserved for gradient()
 

paddle/fluid/eager/custom_operator/custom_operator_node.cc

@@ -164,13 +164,11 @@ static void ConstructFwdAndBwdMap(
   }
 }
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     kSlotSmallVectorSize>
-RunCustomOpNode::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         kSlotSmallVectorSize>& grads,
-    bool create_graph,
-    bool is_new_grad) {  // NOLINT
+paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
+RunCustomOpNode::operator()(paddle::small_vector<std::vector<paddle::Tensor>,
+                                                 kSlotSmallVectorSize>& grads,
+                            bool create_graph,
+                            bool is_new_grad) {  // NOLINT
   paddle::CustomOpKernelContext ctx;
   auto grad_inputs_name = paddle::framework::OpMetaInfoHelper::GetInputs(
       egr::Controller::Instance().GetOpMetaInfoMap().at(op_type_)[1]);
@@ -179,8 +177,7 @@ RunCustomOpNode::operator()(
   auto map = egr::Controller::Instance().GetCustomEdgesSlotMap().at(op_type_);
   auto kernel_map = egr::Controller::Instance().GetOpMetaInfoMap();
 
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       tmp_ins(grad_inputs_name.size());
   VLOG(7) << " Prepare Backward inputs of grads with size: " << grads.size()
           << ", whose grad_inputs_name size is: " << grad_inputs_name.size();
@@ -208,11 +205,9 @@ RunCustomOpNode::operator()(
   }
   VLOG(6) << "Prepare Grad attrs";
   ctx.EmplaceBackAttrs(attrs_);
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
-      outs(OutputMeta().size());
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize> outs(
+      OutputMeta().size());
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       tmp_outs(grad_outputs_names.size());
   VLOG(6) << "Prepare Grad outputs for size: " << grad_outputs_names.size();
   for (size_t i = 0; i < OutputMeta().size(); i++) {
@@ -289,9 +284,8 @@ RunCustomOpNode::operator()(
     // Prepare Grad outputs
     size_t no_grad_cnt = 0;
     for (size_t i = 0; i < ins_auto_grad_metas.size(); i++) {
-      const std::vector<paddle::experimental::Tensor>& in_tensors =
-          ctx.InputsBetween(ctx.InputRangeAt(i).first,
-                            ctx.InputRangeAt(i).second);
+      const std::vector<paddle::Tensor>& in_tensors = ctx.InputsBetween(
+          ctx.InputRangeAt(i).first, ctx.InputRangeAt(i).second);
 
       if (slot_map[1][0].find(i) != slot_map[1][0].end()) {
         grad_node->SetGradOutMeta(in_tensors, slot_map[1][0][i]);
@@ -304,9 +298,8 @@ RunCustomOpNode::operator()(
 
     // Prepare Grad inputs with grad of fwd outputs
     for (size_t i = 0; i < outs_auto_grad_metas.size(); i++) {
-      const std::vector<paddle::experimental::Tensor>& out_tensors =
-          ctx.OutputsBetweeen(ctx.OutputRangeAt(i).first,
-                              ctx.OutputRangeAt(i).second);
+      const std::vector<paddle::Tensor>& out_tensors = ctx.OutputsBetweeen(
+          ctx.OutputRangeAt(i).first, ctx.OutputRangeAt(i).second);
       egr::EagerUtils::SetOutRankWithSlot(&(outs_auto_grad_metas[i]), i);
       egr::EagerUtils::SetHistory(&(outs_auto_grad_metas[i]), grad_node);
       grad_node->SetGradInMeta(out_tensors, i);
@@ -347,11 +340,10 @@ RunCustomOpNode::operator()(
   return outs;
 }
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
 RunCustomOpDoubleGradNode::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         kSlotSmallVectorSize>& grads,
+    paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>&
+        grads,
     bool create_graph,
     bool is_new_grad) {  // NOLINT
   paddle::CustomOpKernelContext ctx;
@@ -364,8 +356,7 @@ RunCustomOpDoubleGradNode::operator()(
   auto map = egr::Controller::Instance().GetCustomEdgesSlotMap().at(op_type_);
   auto kernel_map = egr::Controller::Instance().GetOpMetaInfoMap();
 
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       tmp_ins(grad_inputs_name.size());
   VLOG(7) << " Prepare Backward inputs of grads with size: " << grads.size()
           << ", whose grad_inputs_name size is: " << grad_inputs_name.size();
@@ -395,11 +386,9 @@ RunCustomOpDoubleGradNode::operator()(
   }
   VLOG(6) << "Prepare Grad attrs";
   ctx.EmplaceBackAttrs(attrs_);
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
-      outs(OutputMeta().size());
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize> outs(
+      OutputMeta().size());
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       tmp_outs(grad_outputs_names.size());
   VLOG(6) << "Prepare Grad outputs for size: " << grad_outputs_names.size();
 

paddle/fluid/eager/custom_operator/custom_operator_node.h

@@ -37,10 +37,10 @@ class RunCustomOpNode : public GradNodeBase {
   }
 
   // Functor: perform backward computations
-  virtual paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  virtual paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>
   operator()(  // NOLINT
-      paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+      paddle::small_vector<std::vector<paddle::Tensor>,
                            kSlotSmallVectorSize>& grads,  // NOLINT
       bool create_graph = false,
       bool is_new_grad = false)  // NOLINT
@@ -51,7 +51,7 @@ class RunCustomOpNode : public GradNodeBase {
   }
 
   static std::vector<egr::TensorWrapper> ConstructTensorWrapper(
-      const std::vector<paddle::experimental::Tensor>& fwd_var) {
+      const std::vector<paddle::Tensor>& fwd_var) {
     std::vector<egr::TensorWrapper> res;
     for (auto const& var : fwd_var) {
       res.emplace_back(var);
@@ -59,9 +59,9 @@ class RunCustomOpNode : public GradNodeBase {
     return res;
   }
 
-  static std::vector<paddle::experimental::Tensor> Recover(
+  static std::vector<paddle::Tensor> Recover(
       std::vector<egr::TensorWrapper>* fwd_var) {
-    std::vector<paddle::experimental::Tensor> res;
+    std::vector<paddle::Tensor> res;
     for (size_t i = 0; i < fwd_var->size(); i++) {
       res.emplace_back(fwd_var->at(i).recover());
     }
@@ -107,10 +107,10 @@ class RunCustomOpDoubleGradNode : public GradNodeBase {
   }
 
   // Functor: perform backward computations
-  virtual paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  virtual paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>
   operator()(  // NOLINT
-      paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+      paddle::small_vector<std::vector<paddle::Tensor>,
                            kSlotSmallVectorSize>& grads,  // NOLINT
       bool create_graph = false,
       bool is_new_grad = false)  // NOLINT
@@ -122,7 +122,7 @@ class RunCustomOpDoubleGradNode : public GradNodeBase {
   }
 
   static std::vector<egr::TensorWrapper> ConstructTensorWrapper(
-      const std::vector<paddle::experimental::Tensor>& fwd_var) {
+      const std::vector<paddle::Tensor>& fwd_var) {
     std::vector<egr::TensorWrapper> res;
     for (auto const& var : fwd_var) {
       res.emplace_back(var);
@@ -130,9 +130,9 @@ class RunCustomOpDoubleGradNode : public GradNodeBase {
     return res;
   }
 
-  static std::vector<paddle::experimental::Tensor> Recover(
+  static std::vector<paddle::Tensor> Recover(
       std::vector<egr::TensorWrapper>* fwd_var) {
-    std::vector<paddle::experimental::Tensor> res;
+    std::vector<paddle::Tensor> res;
     for (size_t i = 0; i < fwd_var->size(); i++) {
       res.emplace_back(fwd_var->at(i).recover());
     }

paddle/fluid/eager/eager_amp_auto_cast.h

@@ -18,7 +18,7 @@
 
 namespace egr {
 
-static inline bool NeedCast(const paddle::experimental::Tensor& tensor,
+static inline bool NeedCast(const paddle::Tensor& tensor,
                             const paddle::experimental::DataType& dst_dtype) {
   auto place = tensor.place();
   auto data_type = tensor.dtype();
@@ -45,10 +45,9 @@ static inline bool NeedCast(const paddle::experimental::Tensor& tensor,
   return false;
 }
 
-inline paddle::experimental::Tensor Cast(
-    const paddle::experimental::Tensor& input,
-    const paddle::experimental::DataType& dst_dtype,
-    const bool trace_backward = true) {
+inline paddle::Tensor Cast(const paddle::Tensor& input,
+                           const paddle::experimental::DataType& dst_dtype,
+                           const bool trace_backward = true) {
   if (input.is_sparse_coo_tensor() || input.is_sparse_csr_tensor()) {
     if (trace_backward) {
       return sparse::cast_ad_func(
@@ -66,16 +65,16 @@ inline paddle::experimental::Tensor Cast(
   }
 }
 
-inline std::vector<paddle::experimental::Tensor> EagerAmpAutoCasts(
+inline std::vector<paddle::Tensor> EagerAmpAutoCasts(
     const std::string& inputs_name,
-    const std::vector<paddle::experimental::Tensor>& inputs,
+    const std::vector<paddle::Tensor>& inputs,
     const paddle::experimental::DataType& dst_dtype,
     std::string op_name,
     bool trace_backward = true) {
   VLOG(6) << "AMP AmpAutoCasts:"
           << " inputs(" << inputs_name << ") dst_dtype("
           << phi::DataTypeToString(dst_dtype) << ").";
-  std::vector<paddle::experimental::Tensor> inputs_casted;
+  std::vector<paddle::Tensor> inputs_casted;
   for (auto& input : inputs) {
     if (NeedCast(input, dst_dtype)) {
       inputs_casted.emplace_back(std::move(Cast(input, dst_dtype)));
@@ -86,9 +85,9 @@ inline std::vector<paddle::experimental::Tensor> EagerAmpAutoCasts(
   return inputs_casted;
 }
 
-inline paddle::experimental::Tensor EagerAmpAutoCast(
+inline paddle::Tensor EagerAmpAutoCast(
     const std::string& input_name,
-    const paddle::experimental::Tensor& input,
+    const paddle::Tensor& input,
     const paddle::experimental::DataType& dst_dtype,
     const std::string& op_name,
     bool trace_backward = true) {
@@ -119,9 +118,9 @@ inline paddle::experimental::Tensor EagerAmpAutoCast(
   return input;
 }
 
-inline paddle::optional<paddle::experimental::Tensor> EagerAmpAutoCast(
+inline paddle::optional<paddle::Tensor> EagerAmpAutoCast(
     const std::string& input_name,
-    const paddle::optional<paddle::experimental::Tensor>& input,
+    const paddle::optional<paddle::Tensor>& input,
     const paddle::experimental::DataType& dst_dtype,
     const std::string& op_name,
     bool trace_backward = true) {
@@ -132,10 +131,9 @@ inline paddle::optional<paddle::experimental::Tensor> EagerAmpAutoCast(
   return paddle::none;
 }
 
-inline paddle::optional<std::vector<paddle::experimental::Tensor>>
-EagerAmpAutoCasts(
+inline paddle::optional<std::vector<paddle::Tensor>> EagerAmpAutoCasts(
     const std::string& inputs_name,
-    const paddle::optional<std::vector<paddle::experimental::Tensor>>& inputs,
+    const paddle::optional<std::vector<paddle::Tensor>>& inputs,
     const paddle::experimental::DataType& dst_dtype,
     std::string op_name,
     bool trace_backward = true) {
@@ -143,7 +141,7 @@ EagerAmpAutoCasts(
     return EagerAmpAutoCasts(
         inputs_name, *inputs, dst_dtype, op_name, trace_backward);
   }
-  return paddle::optional<std::vector<paddle::experimental::Tensor>>();
+  return paddle::optional<std::vector<paddle::Tensor>>();
 }
 
 }  // namespace egr

paddle/fluid/eager/eager_layout_auto_tune.h

@@ -20,7 +20,7 @@
 #include "paddle/phi/backends/gpu/gpu_info.h"
 namespace egr {
 inline bool NeedTransLayout(
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& tensors_vector,
     const phi::DataLayout& layout) {
   for (size_t i = 0; i < tensors_vector.size(); i++) {
@@ -35,7 +35,7 @@ inline bool NeedTransLayout(
 
 inline std::shared_ptr<EagerLayoutTransformer> EagerLayoutAutotune(
     const std::string& op_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& tensors_vector) {
   // For agnostic op like add, relu, exp
   auto first_layout = tensors_vector[0][0].layout();
@@ -63,7 +63,7 @@ inline std::shared_ptr<EagerLayoutTransformer> EagerLayoutAutotune(
 template <typename T>
 inline std::shared_ptr<EagerLayoutTransformer> EagerLayoutAutotune(
     const std::string& op_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& tensors_vector,
     T* attr) {
   // For lightly op like reduce
@@ -78,7 +78,7 @@ inline std::shared_ptr<EagerLayoutTransformer> EagerLayoutAutotune(
 template <typename T1, typename T2>
 inline std::shared_ptr<EagerLayoutTransformer> EagerLayoutAutotune(
     const std::string& op_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& tensors_vector,
     T1* axis,
     T2* keep_dim) {
@@ -89,7 +89,7 @@ inline std::shared_ptr<EagerLayoutTransformer> EagerLayoutAutotune(
 template <>
 inline std::shared_ptr<EagerLayoutTransformer> EagerLayoutAutotune(
     const std::string& op_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& tensors_vector,
     std::string* attr) {
   // Heavily op with (string) data_format, data_layout
@@ -142,7 +142,7 @@ inline std::shared_ptr<EagerLayoutTransformer> EagerLayoutAutotune(
 template <>
 inline std::shared_ptr<EagerLayoutTransformer> EagerLayoutAutotune(
     const std::string& op_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& tensors_vector,
     std::vector<int>* attr) {
   // lightly  transpose
@@ -167,7 +167,7 @@ template <>
 inline std::shared_ptr<EagerLayoutTransformer>
 EagerLayoutAutotune<paddle::experimental::Scalar, bool>(
     const std::string& op_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& tensors_vector,
     paddle::experimental::Scalar* axis,
     bool* keep_dim) {
@@ -191,7 +191,7 @@ EagerLayoutAutotune<paddle::experimental::Scalar, bool>(
 template <>
 inline std::shared_ptr<EagerLayoutTransformer> EagerLayoutAutotune<int, int>(
     const std::string& op_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& tensors_vector,
     int* start_axis,
     int* stop_axis) {
@@ -215,7 +215,7 @@ template <>
 inline std::shared_ptr<EagerLayoutTransformer>
 EagerLayoutAutotune<paddle::experimental::Scalar>(
     const std::string& op_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& tensors_vector,
     paddle::experimental::Scalar* axis) {
   if (DesiredLayout() == phi::DataLayout::UNDEFINED) {

paddle/fluid/eager/eager_layout_transformer.h

@@ -19,8 +19,8 @@
 #include "paddle/phi/core/dense_tensor.h"
 #include "paddle/phi/core/tensor_utils.h"
 namespace egr {
-inline paddle::experimental::Tensor EagerTraceTransposeOp(
-    const phi::DataLayout layout, const paddle::experimental::Tensor& in) {
+inline paddle::Tensor EagerTraceTransposeOp(const phi::DataLayout layout,
+                                            const paddle::Tensor& in) {
   VLOG(4) << "AutoTune Transpose from " << in.layout() << " to " << layout
           << ", tensor's dim size is " << in.shape().size();
   if (in.shape().size() != 4) {
@@ -47,7 +47,7 @@ inline phi::DataLayout DefaultLayout() {
   return paddle::imperative::LayoutAutoTune::Instance().GetDefaultLayout();
 }
 
-inline void UpdateLayout(paddle::experimental::Tensor* out_tensor,
+inline void UpdateLayout(paddle::Tensor* out_tensor,
                          const phi::DataLayout layout) {
   if (out_tensor->layout() != layout) {
     VLOG(4) << "Update out_tensor's layout from " << out_tensor->layout()
@@ -58,7 +58,7 @@ inline void UpdateLayout(paddle::experimental::Tensor* out_tensor,
   }
 }
 
-inline void DealWithShapeOp(paddle::experimental::Tensor* out_tensor,
+inline void DealWithShapeOp(paddle::Tensor* out_tensor,
                             const phi::DataLayout layout,
                             int dim_size) {
   auto des_layout = DesiredLayout();
@@ -114,7 +114,7 @@ class EagerLayoutTransformer {
 
   explicit EagerLayoutTransformer(
       const std::string& op_name,
-      const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+      const paddle::small_vector<std::vector<paddle::Tensor>,
                                  kSlotSmallVectorSize>& tensors_vector,
       const Layout final_layout = Layout::UNDEFINED)
       : op_name_(op_name), final_layout_(final_layout), dim_size_(1) {
@@ -123,8 +123,8 @@ class EagerLayoutTransformer {
 
   virtual ~EagerLayoutTransformer() {}
 
-  virtual paddle::experimental::Tensor TransInTensor(
-      const std::string& in_name, const paddle::experimental::Tensor& in) {
+  virtual paddle::Tensor TransInTensor(const std::string& in_name,
+                                       const paddle::Tensor& in) {
     // update in shape size
     dim_size_ = in.shape().size();
     bool need_trans =
@@ -140,27 +140,23 @@ class EagerLayoutTransformer {
     return in;
   }
 
-  virtual paddle::optional<paddle::experimental::Tensor> TransInTensor(
-      const std::string& in_name,
-      const paddle::optional<paddle::experimental::Tensor>& in) {
+  virtual paddle::optional<paddle::Tensor> TransInTensor(
+      const std::string& in_name, const paddle::optional<paddle::Tensor>& in) {
     return in ? TransInTensor(in_name, *in) : in;
   }
 
-  virtual std::vector<paddle::experimental::Tensor> TransInTensors(
-      const std::string& in_name,
-      const std::vector<paddle::experimental::Tensor>& in) {
+  virtual std::vector<paddle::Tensor> TransInTensors(
+      const std::string& in_name, const std::vector<paddle::Tensor>& in) {
     return in;
   }
 
-  virtual paddle::optional<std::vector<paddle::experimental::Tensor>>
-  TransInTensors(
+  virtual paddle::optional<std::vector<paddle::Tensor>> TransInTensors(
       const std::string& in_name,
-      const paddle::optional<std::vector<paddle::experimental::Tensor>>& in) {
+      const paddle::optional<std::vector<paddle::Tensor>>& in) {
     return (in ? TransInTensors(in_name, *in) : in);
   }
 
-  virtual void SetOutTensorLayout(
-      std::vector<paddle::experimental::Tensor>* out_tensor) {
+  virtual void SetOutTensorLayout(std::vector<paddle::Tensor>* out_tensor) {
     bool update_layout = !(final_layout_ == Layout::UNDEFINED);
     if (update_layout) {
       for (size_t i = 0; i < out_tensor->size(); i++) {
@@ -172,16 +168,16 @@ class EagerLayoutTransformer {
   }
 
   virtual void SetOutTensorLayout(
-      paddle::optional<paddle::experimental::Tensor>* out_tensor) {
+      paddle::optional<paddle::Tensor>* out_tensor) {
     VLOG(4) << "AutoTune out tensor is optional";
   }
 
   virtual void SetOutTensorLayout(
-      paddle::optional<std::vector<paddle::experimental::Tensor>>* out_tensor) {
+      paddle::optional<std::vector<paddle::Tensor>>* out_tensor) {
     VLOG(4) << "AutoTune out tensor is optional";
   }
 
-  virtual void SetOutTensorLayout(paddle::experimental::Tensor* out_tensor) {
+  virtual void SetOutTensorLayout(paddle::Tensor* out_tensor) {
     if (op_name_ == "shape") {
       return DealWithShapeOp(out_tensor, final_layout_, dim_size_);
     }
@@ -206,8 +202,8 @@ class EagerHeavilyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {
     *layout = phi::DataLayoutToString(DesiredLayout());
   }
 
-  paddle::experimental::Tensor TransInTensor(
-      const std::string& in_name, const paddle::experimental::Tensor& in) {
+  paddle::Tensor TransInTensor(const std::string& in_name,
+                               const paddle::Tensor& in) {
     if (heavily_input_.count(in_name) != 0 && in.layout() != desired_layout_) {
       auto out_tensor = EagerTraceTransposeOp(desired_layout_, in);
       return out_tensor;
@@ -215,19 +211,17 @@ class EagerHeavilyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {
     return in;
   }
 
-  void SetOutTensorLayout(paddle::experimental::Tensor* out_tensor) {
+  void SetOutTensorLayout(paddle::Tensor* out_tensor) {
     UpdateLayout(out_tensor, desired_layout_);
   }
 
-  void SetOutTensorLayout(
-      std::vector<paddle::experimental::Tensor*>* out_tensor) {
+  void SetOutTensorLayout(std::vector<paddle::Tensor*>* out_tensor) {
     for (size_t i = 0; i < out_tensor->size(); i++) {
       SetOutTensorLayout((*out_tensor)[i]);
     }
   }
 
-  void SetOutTensorLayout(
-      std::vector<paddle::experimental::Tensor>* out_tensor) {
+  void SetOutTensorLayout(std::vector<paddle::Tensor>* out_tensor) {
     for (size_t i = 0; i < out_tensor->size(); i++) {
       if ((*out_tensor)[i].layout() != desired_layout_) {
         VLOG(4) << "Update out_tensor's layout from "
@@ -256,8 +250,8 @@ class EagerLightlyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {
   }
 
   // transpose from desired to default
-  paddle::experimental::Tensor TransInTensor(
-      const std::string& in_name, const paddle::experimental::Tensor& in) {
+  paddle::Tensor TransInTensor(const std::string& in_name,
+                               const paddle::Tensor& in) {
     std::string input_layout = phi::DataLayoutToString(in.layout());
     auto default_layout = DefaultLayout();
     if (final_layout_ == input_layout && in.shape().size() == 4) {
@@ -270,10 +264,9 @@ class EagerLightlyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {
     return in;
   }
 
-  virtual std::vector<paddle::experimental::Tensor> TransInTensors(
-      const std::string& in_name,
-      const std::vector<paddle::experimental::Tensor>& in) {
-    std::vector<paddle::experimental::Tensor> result;
+  virtual std::vector<paddle::Tensor> TransInTensors(
+      const std::string& in_name, const std::vector<paddle::Tensor>& in) {
+    std::vector<paddle::Tensor> result;
     auto desired_layout = DesiredLayout();
     auto default_layout = DefaultLayout();
     for (size_t i = 0; i < in.size(); i++) {
@@ -292,19 +285,17 @@ class EagerLightlyLayoutSensitiveOpTransformer : public EagerLayoutTransformer {
     return result;
   }
 
-  void SetOutTensorLayout(paddle::experimental::Tensor* out_tensor) {
+  void SetOutTensorLayout(paddle::Tensor* out_tensor) {
     UpdateLayout(out_tensor, DefaultLayout());
   }
 
-  void SetOutTensorLayout(
-      std::vector<paddle::experimental::Tensor*>* out_tensor) {
+  void SetOutTensorLayout(std::vector<paddle::Tensor*>* out_tensor) {
     for (size_t i = 0; i < out_tensor->size(); i++) {
       SetOutTensorLayout((*out_tensor)[i]);
     }
   }
 
-  void SetOutTensorLayout(
-      std::vector<paddle::experimental::Tensor>* out_tensor) {
+  void SetOutTensorLayout(std::vector<paddle::Tensor>* out_tensor) {
     auto default_layout = DefaultLayout();
     for (size_t i = 0; i < out_tensor->size(); i++) {
       phi::DenseTensorUtils::GetMutableMeta(
@@ -336,12 +327,12 @@ class EagerTransposeOpTransformer
     (*axis)[3] = perm[(*axis)[3]];
   }
 
-  paddle::experimental::Tensor TransInTensor(
-      const std::string& in_name, const paddle::experimental::Tensor& in) {
+  paddle::Tensor TransInTensor(const std::string& in_name,
+                               const paddle::Tensor& in) {
     return in;
   }
 
-  void SetOutTensorLayout(paddle::experimental::Tensor* out_tensor) {
+  void SetOutTensorLayout(paddle::Tensor* out_tensor) {
     UpdateLayout(out_tensor, DefaultLayout());
   }
 };
@@ -362,7 +353,7 @@ class EagerArgmaxOpTransformer
     (*axis) = static_cast<paddle::experimental::Scalar>(perm[axes]);
   }
 
-  void SetOutTensorLayout(paddle::experimental::Tensor* out_tensor) {
+  void SetOutTensorLayout(paddle::Tensor* out_tensor) {
     UpdateLayout(out_tensor, DesiredLayout());
   }
 };
@@ -376,12 +367,12 @@ class EagerFlattenOpTransformer
   }
 
   // transpose from NHWC to NCHW
-  paddle::experimental::Tensor TransInTensor(
-      const std::string& in_name, const paddle::experimental::Tensor& in) {
+  paddle::Tensor TransInTensor(const std::string& in_name,
+                               const paddle::Tensor& in) {
     return in;
   }
 
-  void SetOutTensorLayout(paddle::experimental::Tensor* out_tensor) {
+  void SetOutTensorLayout(paddle::Tensor* out_tensor) {
     UpdateLayout(out_tensor, DefaultLayout());
   }
 };
@@ -403,13 +394,12 @@ class EagerConcatOpTransformer
     (*axis) = static_cast<paddle::experimental::Scalar>(perm[axes]);
   }
 
-  virtual std::vector<paddle::experimental::Tensor> TransInTensors(
-      const std::string& in_name,
-      const std::vector<paddle::experimental::Tensor>& in) {
+  virtual std::vector<paddle::Tensor> TransInTensors(
+      const std::string& in_name, const std::vector<paddle::Tensor>& in) {
     return in;
   }
 
-  void SetOutTensorLayout(paddle::experimental::Tensor* out_tensor) {
+  void SetOutTensorLayout(paddle::Tensor* out_tensor) {
     UpdateLayout(out_tensor, DesiredLayout());
   }
 };

paddle/fluid/eager/eager_tensor.h

@@ -26,7 +26,7 @@ namespace egr {
 /**
  * VariableCompatTensor class is used by Eager mode for now. It's painful to
  * do this in Eager Mode, the better choice is to design the special Tensor
- * directly in phi and use it in paddle::experimental::Tensor.
+ * directly in phi and use it in paddle::Tensor.
  * However, we have some special operators, and they use special input variable
  * type, such as vector<string>, unordered_map<wstring, int>, these type cannot
  * cover by DenseTensor or SparseTensor. So, we have to provide a compatible
@@ -178,22 +178,22 @@ class VariableCompatTensor
   std::shared_ptr<Placeholder> holder_;
 };
 
-inline bool IsVariableCompatTensor(const paddle::experimental::Tensor& tensor) {
+inline bool IsVariableCompatTensor(const paddle::Tensor& tensor) {
   return VariableCompatTensor::classof(tensor.impl().get());
 }
 
 /**
  * This class is used by Eager mode for now. It's painful to do this in Eager
- * Mode, the better choice is to use paddle::experimental::Tensor directly.
+ * Mode, the better choice is to use paddle::Tensor directly.
  * However, we have a punch of nested kernel code, and they use
  * paddle::framework::Variable in inner logic code. So, we have to provide
  * variable in paddle::framework::ExecutionContext to support it. We should
  * remove this as soon as we finish our latest Phi Lib, and use
- * paddle::experimental::Tensor instead.
+ * paddle::Tensor instead.
  *
  * Note: Keep this class as clean as possible.
  * This class should only support method declared in
- * paddle::experimental::Tensor with access method of
+ * paddle::Tensor with access method of
  * paddle::framework::Variable no more members are acceptable.
  * **/
 class EagerVariable final {
@@ -204,8 +204,7 @@ class EagerVariable final {
 
   explicit EagerVariable(const std::string& name) : name_(name) {}
 
-  explicit EagerVariable(const paddle::experimental::Tensor& tensor)
-      : name_(tensor.name()) {
+  explicit EagerVariable(const paddle::Tensor& tensor) : name_(tensor.name()) {
     if (tensor.defined()) {
       if (tensor.is_dense_tensor()) {
         ConstructVariableFromTensor<phi::DenseTensor>(tensor);
@@ -283,7 +282,7 @@ class EagerVariable final {
   }
 
   template <typename VarType>
-  void ConstructVariableFromTensor(const paddle::experimental::Tensor& tensor) {
+  void ConstructVariableFromTensor(const paddle::Tensor& tensor) {
     auto* framework_tensor = var_.GetMutable<VarType>();
     // Contruct phi::DenseTensor from egr::EagerVariable
     auto tensor_dense = std::dynamic_pointer_cast<VarType>(tensor.impl());
@@ -299,8 +298,7 @@ class EagerVariable final {
   }
 
   template <typename VarType>
-  void ConstructVariableFromCompatTensor(
-      const paddle::experimental::Tensor& tensor) {
+  void ConstructVariableFromCompatTensor(const paddle::Tensor& tensor) {
     auto* framework_holder = var_.GetMutable<VarType>();
     // Contruct phi::DenseTensor from egr::EagerVariable
     auto* compat_tensor =

paddle/fluid/eager/general_grad.h

@@ -40,9 +40,8 @@ class GeneralGrad {
   static GeneralGrad& Instance() { return *general_grad_; }
 
   // Get inputs's / no_grad_vars's GradNodes and InputMeta Info
-  void GetTargetNodesInfo(
-      const std::vector<paddle::experimental::Tensor>& inputs,
-      bool is_no_grad_vars) {
+  void GetTargetNodesInfo(const std::vector<paddle::Tensor>& inputs,
+                          bool is_no_grad_vars) {
     std::string msg = is_no_grad_vars ? "no_grad_vars" : "inputs";
     VLOG(6) << "Running in GetTargetNodesInfo.";
     if (!inputs.empty()) {
@@ -231,32 +230,29 @@ class GeneralGrad {
               (iter->second)->Buffers()[rank_info.first][rank_info.second];
           // save the target result
           results_map_[input_target_node.first] =
-              std::make_shared<paddle::experimental::Tensor>(target_result);
+              std::make_shared<paddle::Tensor>(target_result);
         }
       }
     }  // TODO(jiabin): Some check here.
   }
 
   void SetResultForEnddingNodes(
-      paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                           kSlotSmallVectorSize> grad_output,
+      paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
+          grad_output,
       GradNodeBase* node) {
     if (IsEnddingNodes(node)) {
       VLOG(6) << "Set result for endding_nodes_ with grad_output_tensors";
-      results_map_[node] =
-          std::make_shared<paddle::experimental::Tensor>(grad_output[0][0]);
+      results_map_[node] = std::make_shared<paddle::Tensor>(grad_output[0][0]);
     }
   }
 
-  std::shared_ptr<paddle::experimental::Tensor> FetchGradForTensor(
-      const paddle::experimental::Tensor& tensor,
-      egr::GradNodeBase* target_node) {
-    std::shared_ptr<paddle::experimental::Tensor> tmp{
-        std::make_shared<paddle::experimental::Tensor>()};
+  std::shared_ptr<paddle::Tensor> FetchGradForTensor(
+      const paddle::Tensor& tensor, egr::GradNodeBase* target_node) {
+    std::shared_ptr<paddle::Tensor> tmp{std::make_shared<paddle::Tensor>()};
     VLOG(6)
         << "Running in FetchGradForTensor, prepare FetchGrad Hook for tensor: "
         << tensor.name();
-    auto hook = [tmp](const paddle::experimental::Tensor& t) {
+    auto hook = [tmp](const paddle::Tensor& t) {
       auto tmp_grad = tmp.get();
       if (t.defined()) {
         VLOG(6) << "Set impl for FetchGrad Hook for tensor: " << t.name();
@@ -264,8 +260,8 @@ class GeneralGrad {
         tmp_grad->set_autograd_meta(t.mutable_autograd_meta());
         return t;
       } else {
-        VLOG(6) << "Retain NULL paddle::experimental::Tensor in FetchGrad Hook";
-        return paddle::experimental::Tensor();
+        VLOG(6) << "Retain NULL paddle::Tensor in FetchGrad Hook";
+        return paddle::Tensor();
       }
     };
 
@@ -283,8 +279,7 @@ class GeneralGrad {
   // backward graph, use grad node's output as inputs' gradients and no need to
   // register Hook. Please note that endding node must be GradNodeAccumulation
   // after ModifyBackwardGraph function.
-  void RegisterFetchGradHook(
-      const std::vector<paddle::experimental::Tensor>& inputs) {
+  void RegisterFetchGradHook(const std::vector<paddle::Tensor>& inputs) {
     VLOG(6) << "Running in RegisterFetchGradHook.";
     if (!inputs.empty()) {
       size_t num_inputs = inputs.size();
@@ -436,14 +431,14 @@ class GeneralGrad {
     }
   }
 
-  std::vector<paddle::experimental::Tensor> GetResults(
-      const std::vector<paddle::experimental::Tensor>& inputs,
+  std::vector<paddle::Tensor> GetResults(
+      const std::vector<paddle::Tensor>& inputs,
       bool allow_unused,
       bool create_graph) {
     VLOG(6) << "Running in GetResults";
     if (inputs.empty()) return {};
 
-    std::vector<paddle::experimental::Tensor> results;
+    std::vector<paddle::Tensor> results;
     results.reserve(inputs.size());
 
     for (size_t i = 0; i < inputs.size(); ++i) {
@@ -582,8 +577,8 @@ class GeneralGrad {
   }
 
   void PreparedForGeneralGrad(
-      const std::vector<paddle::experimental::Tensor>& inputs,
-      const std::vector<paddle::experimental::Tensor>& no_grad_vars,
+      const std::vector<paddle::Tensor>& inputs,
+      const std::vector<paddle::Tensor>& no_grad_vars,
       const std::deque<GradNodeBase*>& orig_queue,
       std::deque<GradNodeBase*>* queue,
       const std::unordered_map<GradNodeBase*,
@@ -645,8 +640,7 @@ class GeneralGrad {
   std::unordered_map<GradNodeBase* /* next node */,
                      std::unordered_set<GradNodeBase*> /* pre nodes */>
       depending_nodes_;
-  std::unordered_map<GradNodeBase*,
-                     std::shared_ptr<paddle::experimental::Tensor>>
+  std::unordered_map<GradNodeBase*, std::shared_ptr<paddle::Tensor>>
       results_map_;
 
   std::vector<std::shared_ptr<GradNodeBase>> copied_grad_nodes_;

paddle/fluid/eager/grad_node_info.cc

@@ -34,8 +34,7 @@
  **/
 namespace egr {
 
-static void CheckTensor(const paddle::experimental::Tensor& pre,
-                        const paddle::experimental::Tensor& post) {
+static void CheckTensor(const paddle::Tensor& pre, const paddle::Tensor& post) {
   if (!pre.initialized() && post.initialized()) {
     PADDLE_THROW(paddle::platform::errors::PermissionDenied(
         "The tensor in before and after hook are not consistent"));
@@ -82,7 +81,7 @@ GradNodeBase::MutableOutputMeta() {
   return bwd_out_meta_;
 }
 
-void GradNodeBase::SetGradInMeta(const paddle::experimental::Tensor& fwd_out,
+void GradNodeBase::SetGradInMeta(const paddle::Tensor& fwd_out,
                                  size_t slot_rank) {
   VLOG(7) << "Set GradSlotMeta for Grad Inputs";
   auto* fwd_out_meta = egr::EagerUtils::nullable_autograd_meta(fwd_out);
@@ -142,9 +141,8 @@ void GradNodeBase::SetGradInMeta(const paddle::experimental::Tensor& fwd_out,
   }
 }
 
-void GradNodeBase::SetGradInMeta(
-    const std::vector<paddle::experimental::Tensor>& fwd_out,
-    size_t slot_rank) {
+void GradNodeBase::SetGradInMeta(const std::vector<paddle::Tensor>& fwd_out,
+                                 size_t slot_rank) {
   VLOG(7) << "Set GradSlotMeta for Grad Inputs";
   size_t slot_size = fwd_out.size();
   PADDLE_ENFORCE_LE(
@@ -208,7 +206,7 @@ void GradNodeBase::SetGradInMeta(
   }
 }
 
-void GradNodeBase::SetGradOutMeta(const paddle::experimental::Tensor& fwd_in,
+void GradNodeBase::SetGradOutMeta(const paddle::Tensor& fwd_in,
                                   size_t slot_rank) {
   auto* fwd_in_meta = egr::EagerUtils::nullable_autograd_meta(fwd_in);
   PADDLE_ENFORCE_LE(
@@ -265,8 +263,8 @@ void GradNodeBase::SetGradOutMeta(const paddle::experimental::Tensor& fwd_in,
   }
 }
 
-void GradNodeBase::SetGradOutMeta(
-    const std::vector<paddle::experimental::Tensor>& fwd_in, size_t slot_rank) {
+void GradNodeBase::SetGradOutMeta(const std::vector<paddle::Tensor>& fwd_in,
+                                  size_t slot_rank) {
   size_t slot_size = fwd_in.size();
   PADDLE_ENFORCE_LE(
       slot_rank,
@@ -327,8 +325,7 @@ void GradNodeBase::SetGradOutMeta(
 }
 
 void GradNodeBase::SetGradOutMeta(
-    const std::vector<const paddle::experimental::Tensor*>& fwd_in,
-    size_t slot_rank) {
+    const std::vector<const paddle::Tensor*>& fwd_in, size_t slot_rank) {
   size_t slot_size = fwd_in.size();
   PADDLE_ENFORCE_LE(
       slot_rank,
@@ -406,14 +403,12 @@ int64_t GradNodeBase::RegisterGradientHook(
   return next_hook_id_++;
 }
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
 GradNodeBase::ApplyGradientHooks(
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>& tensors) {
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
-      outs(tensors.size());
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize> outs(
+      tensors.size());
   for (auto& hook_pair : gradient_hooks_) {
     size_t slot_id = std::get<0>(hook_pair.second);
     size_t rank = std::get<1>(hook_pair.second);
@@ -431,9 +426,9 @@ GradNodeBase::ApplyGradientHooks(
                        "than rank size of grad_tensors",
                        slot_id));
 
-    std::vector<paddle::experimental::Tensor>& slot_out = outs[slot_id];
+    std::vector<paddle::Tensor>& slot_out = outs[slot_id];
     slot_out.resize(tensors[slot_id].size());
-    paddle::experimental::Tensor& out = slot_out[rank];
+    paddle::Tensor& out = slot_out[rank];
     if (!out.defined() || !out.initialized()) {
       out = (*hook)(tensors[slot_id][rank]);
     } else {
@@ -460,11 +455,10 @@ GradNodeBase::ApplyGradientHooks(
 }
 
 void GradNodeBase::HandleComplexGradToRealGrad(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         kSlotSmallVectorSize>* out_grads) {
+    paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>*
+        out_grads) {
   for (size_t slot_id = 0; slot_id < out_grads->size(); slot_id++) {
-    const std::vector<paddle::experimental::Tensor>& slot_out_grads =
-        (*out_grads)[slot_id];
+    const std::vector<paddle::Tensor>& slot_out_grads = (*out_grads)[slot_id];
     for (size_t rank_id = 0; rank_id < slot_out_grads.size(); rank_id++) {
       const GradSlotMeta& slot_meta = bwd_out_meta_[slot_id][rank_id];
 
@@ -477,7 +471,7 @@ void GradNodeBase::HandleComplexGradToRealGrad(
 
       auto fwd_data_type = paddle::framework::TransToProtoVarType(
           slot_meta.GetTensorMeta().dtype);
-      const paddle::experimental::Tensor& grad = slot_out_grads[rank_id];
+      const paddle::Tensor& grad = slot_out_grads[rank_id];
 
       if (paddle::framework::IsComplexType(fwd_data_type)) continue;
 

paddle/fluid/eager/grad_node_info.h

@@ -178,13 +178,13 @@ class GradNodeBase {
    * vector of Tensor which contains grads input of current operator
    *
    * Note: why we need backward inputs and outputs construct as vector of vector
-   * of paddle::experimental::Tensor?
+   * of paddle::Tensor?
    * Since all of paddle op composite in form of {"Slot name ", vector<Var>},
    * so, vector of vector is better choice to fit this format.
    * **/
-  virtual paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  virtual paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>
-  operator()(paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  operator()(paddle::small_vector<std::vector<paddle::Tensor>,
                                   kSlotSmallVectorSize>& grads,  // NOLINT
              bool create_graph = false,
              bool is_new_grad = false) = 0;
@@ -216,18 +216,15 @@ class GradNodeBase {
    * Set bwd ins and outs info with forward vars
    * **/
 
-  void SetGradInMeta(const std::vector<paddle::experimental::Tensor>& fwd_out,
-                     size_t slot_rank);
-  void SetGradInMeta(const paddle::experimental::Tensor& fwd_out,
+  void SetGradInMeta(const std::vector<paddle::Tensor>& fwd_out,
                      size_t slot_rank);
+  void SetGradInMeta(const paddle::Tensor& fwd_out, size_t slot_rank);
 
-  void SetGradOutMeta(const std::vector<paddle::experimental::Tensor>& fwd_in,
+  void SetGradOutMeta(const std::vector<paddle::Tensor>& fwd_in,
                       size_t slot_rank);
-  void SetGradOutMeta(
-      const std::vector<const paddle::experimental::Tensor*>& fwd_in,
-      size_t slot_rank);
-  void SetGradOutMeta(const paddle::experimental::Tensor& fwd_in,
+  void SetGradOutMeta(const std::vector<const paddle::Tensor*>& fwd_in,
                       size_t slot_rank);
+  void SetGradOutMeta(const paddle::Tensor& fwd_in, size_t slot_rank);
   /**
    * Default setters for Grad in/out meta this should be used for same special
    * Node which will not create by user
@@ -269,18 +266,16 @@ class GradNodeBase {
     gradient_hooks_ = hooks;
   }
 
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
-  ApplyGradientHooks(
-      const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                                 kSlotSmallVectorSize>& tensors);
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
+  ApplyGradientHooks(const paddle::small_vector<std::vector<paddle::Tensor>,
+                                                kSlotSmallVectorSize>& tensors);
 
   /**
    * Handle Complex - Real Type Promotion
    * **/
   void HandleComplexGradToRealGrad(
-      paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                           kSlotSmallVectorSize>* out_grads);
+      paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>*
+          out_grads);
   bool NeedComplexToRealConversion() { return need_complex_to_real_; }
 
   virtual std::string name() { return "GradNodeBase"; }

paddle/fluid/eager/grad_tensor_holder.cc

@@ -29,11 +29,10 @@ void GradTensorHolder::SetBufferSlotRankZeros(size_t slot_id, size_t rank) {
       paddle::experimental::zeros_like(buffer_[slot_id][rank]);
 }
 
-void GradTensorHolder::CopyValueFromTensor(
-    size_t slot_id,
-    size_t rank,
-    const paddle::experimental::Tensor& t,
-    bool fill_one) {
+void GradTensorHolder::CopyValueFromTensor(size_t slot_id,
+                                           size_t rank,
+                                           const paddle::Tensor& t,
+                                           bool fill_one) {
   // TODO(jiabin): We need to deal with empty input_buffer with slot size not
   // empty;
   PADDLE_ENFORCE(slot_id < buffer_.size(),
@@ -56,7 +55,7 @@ void GradTensorHolder::CopyValueFromTensor(
           buffer_[slot_id].size(),
           rank));
   if (!fill_one) {
-    paddle::experimental::Tensor& buffer_tensor = buffer_[slot_id][rank];
+    paddle::Tensor& buffer_tensor = buffer_[slot_id][rank];
     if ((!buffer_tensor.defined() || !buffer_tensor.initialized())) {
       // Perform deep copy here
       buffer_tensor.copy_(t, t.place(), false);
@@ -97,7 +96,7 @@ void GradTensorHolder::CopyValueFromTensor(
 
 void GradTensorHolder::add(size_t slot_id,
                            size_t rank,
-                           const paddle::experimental::Tensor& t,
+                           const paddle::Tensor& t,
                            bool create_graph) {
   if (!t.initialized()) {
     VLOG(3) << "No need to do accumulate for uninitialized t.";
@@ -122,7 +121,7 @@ void GradTensorHolder::add(size_t slot_id,
           buffer_[slot_id].size(),
           rank));
 
-  paddle::experimental::Tensor& buffer_tensor = buffer_[slot_id][rank];
+  paddle::Tensor& buffer_tensor = buffer_[slot_id][rank];
   // TODO(jiabin): Code bellow is ugly to divide which inner var we used,
   // remove framework::Variable
   // related code later.
@@ -150,35 +149,33 @@ void GradTensorHolder::add(size_t slot_id,
         if (create_graph || t.is_custom_device()) {
           buffer_tensor = add_ad_func(t, buffer_tensor);
         } else {
-          paddle::imperative::TensorAdd<paddle::experimental::Tensor>(
-              t, &buffer_tensor);
+          paddle::imperative::TensorAdd<paddle::Tensor>(t, &buffer_tensor);
         }
       } else {
         // TODO(jiabin): Support Other TensorBase later
         // TODO(zhanlve): Replace SelectedRowsAddTensor with
         // add_dygraph_function once it's supported
-        paddle::experimental::Tensor new_buffer(
-            std::make_shared<phi::DenseTensor>(), "tmp_accumulator");
+        paddle::Tensor new_buffer(std::make_shared<phi::DenseTensor>(),
+                                  "tmp_accumulator");
         paddle::imperative::SelectedRowsAddTensor(
             buffer_tensor, t, &new_buffer);
         buffer_tensor.set_impl(new_buffer.impl());
       }
     } else if (t.is_sparse_coo_tensor()) {
       auto t_sparse = std::dynamic_pointer_cast<phi::SparseCooTensor>(t.impl());
-      paddle::experimental::Tensor t_values(
+      paddle::Tensor t_values(
           std::make_shared<phi::DenseTensor>(t_sparse->non_zero_elements()));
       // In fact, the gradient of SparseTensor is still a SparseTensor
       if (buffer_tensor.is_sparse_coo_tensor()) {
         auto buffer_sparse = std::dynamic_pointer_cast<phi::SparseCooTensor>(
             buffer_tensor.impl());
-        paddle::experimental::Tensor buffer_values(
-            std::make_shared<phi::DenseTensor>(
-                buffer_sparse->non_zero_elements()));
+        paddle::Tensor buffer_values(std::make_shared<phi::DenseTensor>(
+            buffer_sparse->non_zero_elements()));
         if (create_graph || t.is_custom_device()) {
           buffer_values = add_ad_func(t_values, buffer_values);
         } else {
-          paddle::imperative::TensorAdd<paddle::experimental::Tensor>(
-              t_values, &buffer_values);
+          paddle::imperative::TensorAdd<paddle::Tensor>(t_values,
+                                                        &buffer_values);
         }
       }
     } else {
@@ -189,8 +186,8 @@ void GradTensorHolder::add(size_t slot_id,
         paddle::imperative::SelectedRowsAddToTensor(t, &buffer_tensor);
       } else {
         buffer_tensor =
-            std::move(*paddle::imperative::SelectedRowsMerge<
-                      paddle::experimental::Tensor>(t, buffer_tensor));
+            std::move(*paddle::imperative::SelectedRowsMerge<paddle::Tensor>(
+                t, buffer_tensor));
       }
     }
   }

paddle/fluid/eager/grad_tensor_holder.h

@@ -39,9 +39,8 @@ class GradTensorHolder {
 
   GradTensorHolder(const GradTensorHolder& other) = default;
 
-  explicit GradTensorHolder(
-      paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                           kSlotSmallVectorSize>&& inputs)
+  explicit GradTensorHolder(paddle::small_vector<std::vector<paddle::Tensor>,
+                                                 kSlotSmallVectorSize>&& inputs)
       : buffer_(std::move(inputs)) {}
 
   GradTensorHolder& operator=(const GradTensorHolder& other) = default;
@@ -49,20 +48,18 @@ class GradTensorHolder {
   // Create new tensor and copy tensor->impl
   void add(size_t slot_id,
            size_t rank,
-           const paddle::experimental::Tensor& t,
+           const paddle::Tensor& t,
            bool create_graph = false);
   void CopyValueFromTensor(size_t slot_id,
                            size_t rank,
-                           const paddle::experimental::Tensor& t,
+                           const paddle::Tensor& t,
                            bool fill_one = false);
 
-  const std::vector<paddle::experimental::Tensor>& operator[](
-      const size_t& pos) {
+  const std::vector<paddle::Tensor>& operator[](const size_t& pos) {
     return buffer_[pos];
   }
 
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>&
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>&
   Buffers() {
     return buffer_;
   }
@@ -70,8 +67,7 @@ class GradTensorHolder {
   void SetBufferSlotRankZeros(size_t slot_id, size_t rank);
 
  private:
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       buffer_;
 };
 

paddle/fluid/eager/hooks.h

@@ -26,8 +26,7 @@ namespace egr {
 class TensorHook {
  public:
   virtual ~TensorHook() = default;
-  virtual paddle::experimental::Tensor operator()(
-      const paddle::experimental::Tensor& var) = 0;
+  virtual paddle::Tensor operator()(const paddle::Tensor& var) = 0;
 };
 
 class VoidHook {
@@ -38,19 +37,16 @@ class VoidHook {
 
 class CppTensorHook : public TensorHook {
  public:
-  explicit CppTensorHook(const std::function<paddle::experimental::Tensor(
-                             const paddle::experimental::Tensor&)>& fn)
+  explicit CppTensorHook(
+      const std::function<paddle::Tensor(const paddle::Tensor&)>& fn)
       : fn_(std::move(fn)) {}
 
-  paddle::experimental::Tensor operator()(
-      const paddle::experimental::Tensor& var) override {
+  paddle::Tensor operator()(const paddle::Tensor& var) override {
     return fn_(var);
   }
 
  private:
-  std::function<paddle::experimental::Tensor(
-      const paddle::experimental::Tensor&)>
-      fn_;
+  std::function<paddle::Tensor(const paddle::Tensor&)> fn_;
 };
 
 class CppVoidHook : public VoidHook {
@@ -76,14 +72,14 @@ class PackHookBase {
  public:
   virtual ~PackHookBase() = default;
   virtual std::shared_ptr<PyObjectHolderBase> operator()(
-      const paddle::experimental::Tensor& tensor) = 0;
+      const paddle::Tensor& tensor) = 0;
   virtual void* operator()(void* py_tensor) = 0;
 };
 
 class UnPackHookBase {
  public:
   virtual ~UnPackHookBase() = default;
-  virtual paddle::experimental::Tensor operator()(
+  virtual paddle::Tensor operator()(
       std::shared_ptr<PyObjectHolderBase> packed_value) = 0;
   virtual void* operator()(void* packed_value, void* other) = 0;
 };

paddle/fluid/eager/nan_inf_utils.cc

@@ -103,7 +103,7 @@ void CheckTensorHasNanOrInf(const std::string& api_name,
 
 void CheckTensorHasNanOrInf(
     const std::string& api_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                egr::kSlotSmallVectorSize>& tensors) {
   for (auto& tensor_vector : tensors) {
     CheckTensorHasNanOrInf(api_name, tensor_vector);

paddle/fluid/eager/nan_inf_utils.h

@@ -24,7 +24,7 @@
 
 namespace egr {
 
-using paddle::experimental::Tensor;
+using paddle::Tensor;
 using TupleOfTwoTensors = std::tuple<Tensor, Tensor>;
 using TupleOfThreeTensors = std::tuple<Tensor, Tensor, Tensor>;
 using TupleOfFourTensors = std::tuple<Tensor, Tensor, Tensor, Tensor>;
@@ -59,7 +59,7 @@ void CheckTensorHasNanOrInf(const std::string& api_name,
 
 void CheckTensorHasNanOrInf(
     const std::string& api_name,
-    const paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    const paddle::small_vector<std::vector<paddle::Tensor>,
                                egr::kSlotSmallVectorSize>& tensors);
 
 template <typename TupleT, size_t N, size_t Last>

paddle/fluid/eager/pylayer/py_layer_node.cc

@@ -32,18 +32,16 @@ GradNodePyLayer::~GradNodePyLayer() {
   Py_XDECREF(ctx_);
 }
 
-paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                     kSlotSmallVectorSize>
+paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
 GradNodePyLayer::operator()(
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+    paddle::small_vector<std::vector<paddle::Tensor>,
                          kSlotSmallVectorSize>& grads,  // NOLINT
     bool create_graph,
     bool is_new_grad) {
   pybind11::gil_scoped_acquire gil;
   VLOG(3) << "Running Eager Backward Node: " << name();
 
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       hooked_grads = GradNodePyLayer::ApplyGradientHooks(grads);
 
   paddle::pybind::PyLayerObject* ctx =
@@ -64,7 +62,7 @@ GradNodePyLayer::operator()(
       PyObject* pylist = PyList_New((Py_ssize_t)grads[i].size());
       for (size_t j = 0; j < grads[i].size(); j++) {
         if (ctx->materialize_grads && !grads[i][j].initialized()) {
-          paddle::experimental::Tensor tensor_tmp;
+          paddle::Tensor tensor_tmp;
           auto dense_tensor = std::make_shared<phi::DenseTensor>();
           dense_tensor->set_meta(forward_outputs_meta_[i][j]);
           tensor_tmp.set_impl(dense_tensor);
@@ -84,7 +82,7 @@ GradNodePyLayer::operator()(
       PyTuple_SET_ITEM(backward_args, i, pylist);
     } else {
       if (ctx->materialize_grads && !grads[i][0].initialized()) {
-        paddle::experimental::Tensor tensor_tmp;
+        paddle::Tensor tensor_tmp;
         auto dense_tensor = std::make_shared<phi::DenseTensor>();
         dense_tensor->set_meta(forward_outputs_meta_[i][0]);
         tensor_tmp.set_impl(dense_tensor);
@@ -139,8 +137,7 @@ GradNodePyLayer::operator()(
         outputs_size));
   }
 
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       grad_out;
   grad_out.reserve(ctx->forward_input_tensor_is_duplicable.size());
   for (size_t i = 0; i < ctx->forward_input_tensor_is_duplicable.size(); i++) {

paddle/fluid/eager/pylayer/py_layer_node.h

@@ -48,9 +48,9 @@ class GradNodePyLayer : public GradNodeBase {
 
   ~GradNodePyLayer() override;
 
-  virtual paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  virtual paddle::small_vector<std::vector<paddle::Tensor>,
                                kSlotSmallVectorSize>
-  operator()(paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  operator()(paddle::small_vector<std::vector<paddle::Tensor>,
                                   kSlotSmallVectorSize>& grads,  // NOLINT
              bool create_graph = false,
              bool is_new_grad = false) override;
@@ -60,8 +60,7 @@ class GradNodePyLayer : public GradNodeBase {
   std::string name() override { return name_; }
 
   void SaveForwardOutputsMeta(
-      const std::vector<std::vector<paddle::experimental::Tensor*>>&
-          outputs_tensor) {
+      const std::vector<std::vector<paddle::Tensor*>>& outputs_tensor) {
     forward_outputs_meta_.resize(outputs_tensor.size());
     forward_outputs_place_.resize(outputs_tensor.size());
     for (size_t i = 0; i < outputs_tensor.size(); i++) {

paddle/fluid/eager/tensor_wrapper.h

@@ -37,7 +37,7 @@ namespace egr {
 class TensorWrapper {
  public:
   TensorWrapper() = default;
-  explicit TensorWrapper(const paddle::experimental::Tensor& tensor,
+  explicit TensorWrapper(const paddle::Tensor& tensor,
                          bool no_need_buffer = false) {
     // set inplace_version_snapshot_ according to tensor's current inplace
     // version.
@@ -133,12 +133,12 @@ class TensorWrapper {
   }
 #endif
 
-  paddle::experimental::Tensor recover() {
+  paddle::Tensor recover() {
     VLOG(6) << "Recover tensor: " << intermidiate_tensor_.name()
             << " for wrapper";
     if (!intermidiate_tensor_.defined()) {
       VLOG(6) << "Return NULL tensor Here. ";
-      return paddle::experimental::Tensor();
+      return paddle::Tensor();
     }
 #ifndef PADDLE_NO_PYTHON
     if (packed_value_ && unpack_hook_) {
@@ -154,7 +154,7 @@ class TensorWrapper {
     }
 #endif
 
-    paddle::experimental::Tensor recovered_tensor = intermidiate_tensor_;
+    paddle::Tensor recovered_tensor = intermidiate_tensor_;
 
     std::shared_ptr<GradNodeBase> new_grad_node = weak_grad_node_.lock();
     if (new_grad_node) {
@@ -178,9 +178,7 @@ class TensorWrapper {
     return recovered_tensor;
   }
 
-  paddle::experimental::Tensor get_intermidiate_tensor() {
-    return intermidiate_tensor_;
-  }
+  paddle::Tensor get_intermidiate_tensor() { return intermidiate_tensor_; }
 
   void clear() { intermidiate_tensor_.reset(); }
 
@@ -223,7 +221,7 @@ class TensorWrapper {
 
  private:
   bool no_need_buffer_ = false;
-  paddle::experimental::Tensor intermidiate_tensor_;
+  paddle::Tensor intermidiate_tensor_;
   std::weak_ptr<egr::GradNodeBase> weak_grad_node_;
   uint32_t inplace_version_snapshot_ = 0;
 #ifndef PADDLE_NO_PYTHON

paddle/fluid/eager/tests/data_structure_tests/accumulation_node_test.cc

@@ -39,7 +39,7 @@ TEST(AccumulationNode, SelectedRowsAddToTensor) {
   sr0->mutable_value()->Resize(phi::make_ddim({1, 1}));
   sr0->mutable_value()->mutable_data<float>(paddle::platform::CPUPlace())[0] =
       static_cast<float>(10.0f);
-  paddle::experimental::Tensor et0 = paddle::experimental::Tensor(sr0);
+  paddle::Tensor et0 = paddle::Tensor(sr0);
   std::shared_ptr<phi::DenseTensor> dt1 = std::make_shared<phi::DenseTensor>(
       std::make_unique<paddle::experimental::DefaultAllocator>(
           paddle::platform::CPUPlace())
@@ -47,15 +47,14 @@ TEST(AccumulationNode, SelectedRowsAddToTensor) {
       meta);
   dt1->mutable_data<float>(paddle::platform::CPUPlace())[0] =
       static_cast<float>(20.0f);
-  paddle::experimental::Tensor et1 = paddle::experimental::Tensor(dt1);
+  paddle::Tensor et1 = paddle::Tensor(dt1);
   std::shared_ptr<phi::DenseTensor> input_dt =
       std::make_shared<phi::DenseTensor>(
           std::make_unique<paddle::experimental::DefaultAllocator>(
               paddle::platform::CPUPlace())
               .get(),
           meta);
-  paddle::experimental::Tensor input_et =
-      paddle::experimental::Tensor(input_dt);
+  paddle::Tensor input_et = paddle::Tensor(input_dt);
   auto grad_meta = EagerUtils::autograd_meta(&input_et);
   // Initialize Grad Tensor
   std::shared_ptr<phi::SelectedRows> grad_dt =
@@ -69,19 +68,17 @@ TEST(AccumulationNode, SelectedRowsAddToTensor) {
   grad_meta->SetGradNode(node);
   grad_meta->SetStopGradient(false);
   // operator()
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       et0_vec = {{et0}};
-  paddle::experimental::Tensor ret_et0 = node->operator()(et0_vec)[0][0];
+  paddle::Tensor ret_et0 = node->operator()(et0_vec)[0][0];
   auto* ret_et0_ptr =
       std::dynamic_pointer_cast<phi::SelectedRows>(ret_et0.impl())
           ->value()
           .data<float>();
   CHECK_EQ(ret_et0_ptr[0], static_cast<float>(10.0f));
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       et1_vec = {{et1}};
-  paddle::experimental::Tensor ret_et1 = node->operator()(et1_vec)[0][0];
+  paddle::Tensor ret_et1 = node->operator()(et1_vec)[0][0];
   auto* ret_et1_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(ret_et1.impl())
           ->data<float>();
@@ -91,7 +88,7 @@ TEST(AccumulationNode, SelectedRowsAddToTensor) {
                ->value()
                .data<float>()[0],
            static_cast<float>(10.0f));
-  paddle::experimental::Tensor* grad = EagerUtils::mutable_grad(input_et);
+  paddle::Tensor* grad = EagerUtils::mutable_grad(input_et);
   auto* grad_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(grad->impl())->data<float>();
   CHECK_EQ(grad_ptr[0], static_cast<float>(30.0f));
@@ -107,21 +104,20 @@ TEST(AccumulationNode, SelectedRowsMerge) {
   sr0->mutable_value()->Resize(phi::make_ddim({1, 1}));
   sr0->mutable_value()->mutable_data<float>(paddle::platform::CPUPlace())[0] =
       static_cast<float>(10.0f);
-  paddle::experimental::Tensor et0 = paddle::experimental::Tensor(sr0);
+  paddle::Tensor et0 = paddle::Tensor(sr0);
   std::shared_ptr<phi::SelectedRows> sr1 =
       std::make_shared<phi::SelectedRows>(rows, 1);
   sr1->mutable_value()->Resize(phi::make_ddim({1, 1}));
   sr1->mutable_value()->mutable_data<float>(paddle::platform::CPUPlace())[0] =
       static_cast<float>(20.0f);
-  paddle::experimental::Tensor et1 = paddle::experimental::Tensor(sr1);
+  paddle::Tensor et1 = paddle::Tensor(sr1);
   std::shared_ptr<phi::DenseTensor> input_dt =
       std::make_shared<phi::DenseTensor>(
           std::make_unique<paddle::experimental::DefaultAllocator>(
               paddle::platform::CPUPlace())
               .get(),
           meta);
-  paddle::experimental::Tensor input_et =
-      paddle::experimental::Tensor(input_dt);
+  paddle::Tensor input_et = paddle::Tensor(input_dt);
   auto grad_meta = EagerUtils::autograd_meta(&input_et);
   // Initialize Grad Tensor
   std::shared_ptr<phi::SelectedRows> grad_dt =
@@ -135,19 +131,17 @@ TEST(AccumulationNode, SelectedRowsMerge) {
   grad_meta->SetGradNode(node);
   grad_meta->SetStopGradient(false);
   // operator()
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       et0_vec = {{et0}};
-  paddle::experimental::Tensor ret_et0 = node->operator()(et0_vec)[0][0];
+  paddle::Tensor ret_et0 = node->operator()(et0_vec)[0][0];
   auto* ret_et0_ptr =
       std::dynamic_pointer_cast<phi::SelectedRows>(ret_et0.impl())
           ->value()
           .data<float>();
   CHECK_EQ(ret_et0_ptr[0], static_cast<float>(10.0f));
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       et1_vec = {{et1}};
-  paddle::experimental::Tensor ret_et1 = node->operator()(et1_vec)[0][0];
+  paddle::Tensor ret_et1 = node->operator()(et1_vec)[0][0];
   auto* ret_et1_ptr =
       std::dynamic_pointer_cast<phi::SelectedRows>(ret_et1.impl())
           ->value()
@@ -158,7 +152,7 @@ TEST(AccumulationNode, SelectedRowsMerge) {
                ->value()
                .data<float>()[0],
            static_cast<float>(10.0f));
-  paddle::experimental::Tensor* grad = EagerUtils::mutable_grad(input_et);
+  paddle::Tensor* grad = EagerUtils::mutable_grad(input_et);
   auto* grad_ptr = std::dynamic_pointer_cast<phi::SelectedRows>(grad->impl())
                        ->value()
                        .data<float>();
@@ -175,21 +169,20 @@ TEST(AccumulationNode, SelectedRowsAddTensor) {
   sr0->mutable_value()->Resize(phi::make_ddim({1, 1}));
   sr0->mutable_value()->mutable_data<float>(paddle::platform::CPUPlace())[0] =
       static_cast<float>(10.0f);
-  paddle::experimental::Tensor et0 = paddle::experimental::Tensor(sr0);
+  paddle::Tensor et0 = paddle::Tensor(sr0);
   std::shared_ptr<phi::SelectedRows> sr1 =
       std::make_shared<phi::SelectedRows>(rows, 1);
   sr1->mutable_value()->Resize(phi::make_ddim({1, 1}));
   sr1->mutable_value()->mutable_data<float>(paddle::platform::CPUPlace())[0] =
       static_cast<float>(20.0f);
-  paddle::experimental::Tensor et1 = paddle::experimental::Tensor(sr1);
+  paddle::Tensor et1 = paddle::Tensor(sr1);
   std::shared_ptr<phi::DenseTensor> input_dt =
       std::make_shared<phi::DenseTensor>(
           std::make_unique<paddle::experimental::DefaultAllocator>(
               paddle::platform::CPUPlace())
               .get(),
           meta);
-  paddle::experimental::Tensor input_et =
-      paddle::experimental::Tensor(input_dt);
+  paddle::Tensor input_et = paddle::Tensor(input_dt);
   auto grad_meta = EagerUtils::autograd_meta(&input_et);
   // Initialize Grad Tensor
   std::shared_ptr<phi::DenseTensor> grad_dt =
@@ -206,19 +199,17 @@ TEST(AccumulationNode, SelectedRowsAddTensor) {
   grad_meta->SetGradNode(node);
   grad_meta->SetStopGradient(false);
   // operator()
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       et0_vec = {{et0}};
-  paddle::experimental::Tensor ret_et0 = node->operator()(et0_vec)[0][0];
+  paddle::Tensor ret_et0 = node->operator()(et0_vec)[0][0];
   auto* ret_et0_ptr =
       std::dynamic_pointer_cast<phi::SelectedRows>(ret_et0.impl())
           ->value()
           .data<float>();
   CHECK_EQ(ret_et0_ptr[0], static_cast<float>(10.0f));
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       et1_vec = {{et1}};
-  paddle::experimental::Tensor ret_et1 = node->operator()(et1_vec)[0][0];
+  paddle::Tensor ret_et1 = node->operator()(et1_vec)[0][0];
   auto* ret_et1_ptr =
       std::dynamic_pointer_cast<phi::SelectedRows>(ret_et1.impl())
           ->value()
@@ -229,7 +220,7 @@ TEST(AccumulationNode, SelectedRowsAddTensor) {
                ->value()
                .data<float>()[0],
            static_cast<float>(10.0f));
-  paddle::experimental::Tensor* grad = EagerUtils::mutable_grad(input_et);
+  paddle::Tensor* grad = EagerUtils::mutable_grad(input_et);
   auto* grad_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(grad->impl())->data<float>();
   CHECK_EQ(grad_ptr[0], static_cast<float>(30.0f));
@@ -246,7 +237,7 @@ TEST(AccumulationNode, Tensor) {
       meta);
   dt0->mutable_data<paddle::platform::float16>(
       paddle::platform::CPUPlace())[0] = paddle::platform::float16(10.0f);
-  paddle::experimental::Tensor et0 = paddle::experimental::Tensor(dt0);
+  paddle::Tensor et0 = paddle::Tensor(dt0);
 
   std::shared_ptr<phi::DenseTensor> dt1 = std::make_shared<phi::DenseTensor>(
       std::make_unique<paddle::experimental::DefaultAllocator>(
@@ -256,7 +247,7 @@ TEST(AccumulationNode, Tensor) {
 
   dt1->mutable_data<paddle::platform::float16>(
       paddle::platform::CPUPlace())[0] = paddle::platform::float16(20.0f);
-  paddle::experimental::Tensor et1 = paddle::experimental::Tensor(dt1);
+  paddle::Tensor et1 = paddle::Tensor(dt1);
 
   std::shared_ptr<phi::DenseTensor> input_dt =
       std::make_shared<phi::DenseTensor>(
@@ -264,8 +255,7 @@ TEST(AccumulationNode, Tensor) {
               paddle::platform::CPUPlace())
               .get(),
           meta);
-  paddle::experimental::Tensor input_et =
-      paddle::experimental::Tensor(input_dt);
+  paddle::Tensor input_et = paddle::Tensor(input_dt);
   auto grad_meta = EagerUtils::autograd_meta(&input_et);
 
   // Initialize Grad Tensor
@@ -285,19 +275,17 @@ TEST(AccumulationNode, Tensor) {
   grad_meta->SetStopGradient(false);
 
   // operator()
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       et0_vec = {{et0}};
-  paddle::experimental::Tensor ret_et0 = node->operator()(et0_vec)[0][0];
+  paddle::Tensor ret_et0 = node->operator()(et0_vec)[0][0];
   auto* ret_et0_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(ret_et0.impl())
           ->data<paddle::platform::float16>();
   CHECK_EQ(ret_et0_ptr[0], paddle::platform::float16(10.0f));
 
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       et1_vec = {{et1}};
-  paddle::experimental::Tensor ret_et1 = node->operator()(et1_vec)[0][0];
+  paddle::Tensor ret_et1 = node->operator()(et1_vec)[0][0];
 
   auto* ret_et1_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(ret_et1.impl())
@@ -308,7 +296,7 @@ TEST(AccumulationNode, Tensor) {
   CHECK_EQ(std::dynamic_pointer_cast<phi::DenseTensor>(et0.impl())
                ->data<paddle::platform::float16>()[0],
            paddle::platform::float16(10.0f));
-  paddle::experimental::Tensor* grad = EagerUtils::mutable_grad(input_et);
+  paddle::Tensor* grad = EagerUtils::mutable_grad(input_et);
   auto* grad_ptr = std::dynamic_pointer_cast<phi::DenseTensor>(grad->impl())
                        ->data<paddle::platform::float16>();
   CHECK_EQ(grad_ptr[0], paddle::platform::float16(30.0f));
@@ -331,7 +319,7 @@ TEST(AccumulationNode, Tensor) {
   node->RegisterReduceHook(std::make_shared<egr::CppVoidHook>(reduce_hook_1));
 
   // operator()
-  paddle::experimental::Tensor _ret = node->operator()(et0_vec)[0][0];
+  paddle::Tensor _ret = node->operator()(et0_vec)[0][0];
 
   // Check operator() result, should be 36.0
   auto* _ret_ptr = std::dynamic_pointer_cast<phi::DenseTensor>(_ret.impl())

paddle/fluid/eager/tests/data_structure_tests/autograd_meta_test.cc

@@ -22,7 +22,7 @@
 #include "paddle/phi/api/lib/utils/allocator.h"
 
 TEST(AutogradMeta, Constructor) {
-  paddle::experimental::Tensor et1;
+  paddle::Tensor et1;
   auto auto_grad = std::make_shared<egr::AutogradMeta>();
   et1.set_autograd_meta(auto_grad);
   auto* tmp_auto = static_cast<egr::AutogradMeta*>(et1.get_autograd_meta());
@@ -32,7 +32,7 @@ TEST(AutogradMeta, Constructor) {
 }
 
 TEST(AutogradMeta, MemberFunction) {
-  paddle::experimental::Tensor et1;
+  paddle::Tensor et1;
   auto auto_grad = std::make_shared<egr::AutogradMeta>();
   et1.set_autograd_meta(auto_grad);
   auto* tmp_auto = static_cast<egr::AutogradMeta*>(et1.get_autograd_meta());

paddle/fluid/eager/tests/data_structure_tests/eager_tensor_test.cc

@@ -22,7 +22,7 @@
 #include "paddle/phi/core/kernel_registry.h"
 
 namespace eager_test {
-using AbstractAutogradMeta = paddle::experimental::AbstractAutogradMeta;
+using AbstractAutogradMeta = paddle::AbstractAutogradMeta;
 class AutogradMetaTest : public AbstractAutogradMeta {
  public:
   explicit AutogradMetaTest(int val) : val_(val) {}
@@ -30,8 +30,8 @@ class AutogradMetaTest : public AbstractAutogradMeta {
 };
 }  // namespace eager_test
 TEST(Tensor, Constructor) {
-  paddle::experimental::Tensor et1 = paddle::experimental::Tensor();
-  paddle::experimental::Tensor et2 = paddle::experimental::Tensor("et2");
+  paddle::Tensor et1 = paddle::Tensor();
+  paddle::Tensor et2 = paddle::Tensor("et2");
 
   CHECK_EQ(et1.defined(), false);
   CHECK_EQ(et2.name(), "et2");
@@ -46,18 +46,18 @@ TEST(Tensor, Constructor) {
   auto* dt_ptr = dt->mutable_data<float>(paddle::platform::CPUPlace());
   dt_ptr[0] = 5.0f;
   dt_ptr[1] = 10.0f;
-  paddle::experimental::Tensor et3 = paddle::experimental::Tensor(dt);
+  paddle::Tensor et3 = paddle::Tensor(dt);
   auto* et3_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(et3.impl())->data<float>();
   CHECK_EQ(et3_ptr[0], 5.0f);
   CHECK_EQ(et3_ptr[1], 10.0f);
   // copy constructor
-  paddle::experimental::Tensor et4(et3);
+  paddle::Tensor et4(et3);
   auto* et4_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(et4.impl())->data<float>();
   CHECK_EQ(et4_ptr[0], 5.0f);
   CHECK_EQ(et4_ptr[1], 10.0f);
-  paddle::experimental::Tensor et5(std::move(et4));
+  paddle::Tensor et5(std::move(et4));
   auto* et5_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(et5.impl())->data<float>();
   CHECK_EQ(et5_ptr[0], 5.0f);
@@ -65,7 +65,7 @@ TEST(Tensor, Constructor) {
 }
 
 TEST(Tensor, MemberFunction) {
-  paddle::experimental::Tensor et3;
+  paddle::Tensor et3;
   phi::DenseTensorMeta meta =
       phi::DenseTensorMeta(phi::DataType::FLOAT32, phi::make_ddim({1, 2}));
   std::shared_ptr<phi::DenseTensor> dt = std::make_shared<phi::DenseTensor>(
@@ -97,7 +97,7 @@ TEST(Tensor, MemberFunction) {
       std::dynamic_pointer_cast<phi::DenseTensor>(et3.impl())->data<float>();
   CHECK_EQ(dt3_ptr[0], 5.0f);
   CHECK_EQ(dt3_ptr[1], 10.0f);
-  paddle::experimental::Tensor et4 = et3;
+  paddle::Tensor et4 = et3;
   VLOG(6) << "copy =";
   CHECK(et4.initialized() == true);
   auto* dt4_ptr =
@@ -105,7 +105,7 @@ TEST(Tensor, MemberFunction) {
   CHECK_EQ(dt4_ptr[0], 5.0f);
   CHECK_EQ(dt4_ptr[1], 10.0f);
   VLOG(6) << "move =";
-  paddle::experimental::Tensor et5 = std::move(et4);
+  paddle::Tensor et5 = std::move(et4);
   auto* dt5_ptr =
       std::dynamic_pointer_cast<phi::DenseTensor>(et5.impl())->data<float>();
   CHECK_EQ(dt5_ptr[0], 5.0f);
@@ -119,7 +119,7 @@ TEST(Tensor, MemberFunction) {
 }
 
 TEST(EagerVariable, Constructor) {
-  paddle::experimental::Tensor t3;
+  paddle::Tensor t3;
   phi::DenseTensorMeta meta =
       phi::DenseTensorMeta(phi::DataType::FLOAT32, phi::make_ddim({1, 2}));
   std::shared_ptr<phi::DenseTensor> dt = std::make_shared<phi::DenseTensor>(
@@ -142,7 +142,7 @@ TEST(EagerVariable, Constructor) {
   CHECK_EQ(et3.Var().Get<phi::DenseTensor>().data<float>()[0], 5.0f);
   CHECK_EQ(et3.Var().Get<phi::DenseTensor>().data<float>()[1], 10.0f);
   VLOG(6) << "SyncToTensor";
-  paddle::experimental::Tensor t4;
+  paddle::Tensor t4;
   t4.set_impl(et3.GetTensorBase());
   CHECK(t4.initialized() == true);
   VLOG(6) << "Check Tensor";
@@ -156,7 +156,7 @@ TEST(EagerVariable, Constructor) {
   VLOG(6) << "Check Tensor Copy_";
   std::vector<int64_t> rows = {1, 2};
   std::vector<int64_t> dims = {2};
-  paddle::experimental::Tensor t7(std::make_shared<phi::SelectedRows>(rows, 2));
+  paddle::Tensor t7(std::make_shared<phi::SelectedRows>(rows, 2));
   std::dynamic_pointer_cast<phi::SelectedRows>(t7.impl())
       ->mutable_value()
       ->Resize(phi::make_ddim(dims));
@@ -166,11 +166,11 @@ TEST(EagerVariable, Constructor) {
   dt7_tmp_ptr[0] = 6.0f;
   dt7_tmp_ptr[1] = 11.0f;
 
-  paddle::experimental::Tensor t8;
-  paddle::experimental::Tensor t5;
+  paddle::Tensor t8;
+  paddle::Tensor t5;
 #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
-  paddle::experimental::Tensor t6;
-  paddle::experimental::Tensor t9;
+  paddle::Tensor t6;
+  paddle::Tensor t9;
   VLOG(6) << "Check Tensor Copy_ Selected Rows";
   t8.copy_(t7, paddle::platform::CUDAPlace(0), false);
   t9.copy_(t8, paddle::platform::CPUPlace(), false);
@@ -201,7 +201,7 @@ TEST(EagerVariable, Constructor) {
 }
 
 TEST(EagerVariable, DataLayout) {
-  paddle::experimental::Tensor tensor;
+  paddle::Tensor tensor;
   phi::DenseTensorMeta meta = phi::DenseTensorMeta(phi::DataType::FLOAT32,
                                                    phi::make_ddim({1, 1, 1, 1}),
                                                    phi::DataLayout::UNDEFINED);

paddle/fluid/eager/tests/data_structure_tests/grad_node_info_test.cc

@@ -34,8 +34,7 @@ void TestGradNodeBase(bool is_remove_gradient_hook) {
   auto grad_test_node0 = std::make_shared<eager_test::GradTestNode>(
       /* val */ 5.0, /* in_num */ 2, /* out_num */ 2);
   auto grad_test_node1 = std::make_shared<eager_test::GradTestNode>();
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       grads;
   phi::DenseTensorMeta meta =
       phi::DenseTensorMeta(phi::DataType::FLOAT32, phi::make_ddim({1, 1}));
@@ -46,7 +45,7 @@ void TestGradNodeBase(bool is_remove_gradient_hook) {
       meta);
   auto* dt_ptr = dt->mutable_data<float>(paddle::platform::CPUPlace());
   dt_ptr[0] = 5.0f;
-  paddle::experimental::Tensor et1(dt);
+  paddle::Tensor et1(dt);
   grads = {{et1}};
   VLOG(6) << "Test Grad Node Call";
   auto res = (*grad_test_node0)(grads);
@@ -85,9 +84,8 @@ void TestGradNodeBase(bool is_remove_gradient_hook) {
   CHECK_EQ(grad_test_node2->OutputMeta()[0].size(), size_t(1));
 
   VLOG(6) << "Test Gradient Hook";
-  auto gradient_hook = [](const paddle::experimental::Tensor& et)
-      -> paddle::experimental::Tensor {
-    paddle::experimental::Tensor res;
+  auto gradient_hook = [](const paddle::Tensor& et) -> paddle::Tensor {
+    paddle::Tensor res;
     phi::DenseTensorMeta meta =
         phi::DenseTensorMeta(phi::DataType::FLOAT32, phi::make_ddim({1, 1}));
     std::shared_ptr<phi::DenseTensor> dt = std::make_shared<phi::DenseTensor>(
@@ -133,7 +131,7 @@ TEST(GradNodeInfo, Edge) {
           paddle::platform::CPUPlace())
           .get(),
       meta);
-  paddle::experimental::Tensor et1(dt);
+  paddle::Tensor et1(dt);
 
   auto grad_test_node0 = std::make_shared<eager_test::GradTestNode>(5, 2, 2);
   auto auto_grad1 = std::make_shared<egr::AutogradMeta>();

paddle/fluid/eager/tests/data_structure_tests/grad_node_test.h

@@ -30,9 +30,8 @@ class GradTestNode : public egr::GradNodeBase {
       : GradNodeBase(in_num, out_num), val_(val) {}
   GradTestNode() : GradNodeBase() { val_ = 1.0; }
   std::string name() override { return "GradTestNode"; }
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
-  operator()(paddle::small_vector<std::vector<paddle::experimental::Tensor>,
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
+  operator()(paddle::small_vector<std::vector<paddle::Tensor>,
                                   egr::kSlotSmallVectorSize>& grads,  // NOLINT
              bool create_graph = false,
              bool is_new_grad = false) override {
@@ -47,9 +46,8 @@ class GradTestNode : public egr::GradNodeBase {
         meta);
     auto* dt_ptr = dt->mutable_data<float>(paddle::platform::CPUPlace());
     dt_ptr[0] = 6.0f;
-    paddle::experimental::Tensor et1(dt);
-    paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                         egr::kSlotSmallVectorSize>
+    paddle::Tensor et1(dt);
+    paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
         res = {{et1}};
     return res;
   }

paddle/fluid/eager/tests/data_structure_tests/grad_tensor_holder_test.cc

@@ -43,10 +43,9 @@ TEST(GradTensorHolder, Constructor) {
           paddle::platform::CPUPlace())
           .get(),
       meta);
-  paddle::experimental::Tensor et = paddle::experimental::Tensor(dt);
+  paddle::Tensor et = paddle::Tensor(dt);
 
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, kSlotSmallVectorSize>
       inputs;
   inputs.push_back({et});
 
@@ -63,7 +62,7 @@ TEST(GradTensorHolder, Interfaces) {
           .get(),
       meta);
   dt0->mutable_data<float>(paddle::platform::CPUPlace())[0] = 10.0;
-  paddle::experimental::Tensor et0 = paddle::experimental::Tensor(dt0);
+  paddle::Tensor et0 = paddle::Tensor(dt0);
 
   std::shared_ptr<phi::DenseTensor> dt1 = std::make_shared<phi::DenseTensor>(
       std::make_unique<paddle::experimental::DefaultAllocator>(
@@ -71,7 +70,7 @@ TEST(GradTensorHolder, Interfaces) {
           .get(),
       meta);
   dt1->mutable_data<float>(paddle::platform::CPUPlace())[0] = 20.0;
-  paddle::experimental::Tensor et1 = paddle::experimental::Tensor(dt1);
+  paddle::Tensor et1 = paddle::Tensor(dt1);
 
   // Constructor empty GradTensorHolder
   std::vector<GradSlotMeta> slot_meta(1);
@@ -135,8 +134,8 @@ TEST(GradTensorHolder, SelectedRowsMergeAdd) {
     }
   }
   // new 2 phi::Tensor
-  paddle::experimental::Tensor t1(sr1);
-  paddle::experimental::Tensor t2(sr2);
+  paddle::Tensor t1(sr1);
+  paddle::Tensor t2(sr2);
 
   // Constructor empty GradTensorHolder
   std::vector<GradSlotMeta> slot_meta(1);

paddle/fluid/eager/tests/data_structure_tests/tensor_wrapper_test.cc

@@ -21,7 +21,7 @@
 
 TEST(TensorWrapper, Basic) {
   VLOG(6) << "Test Full reserved";
-  paddle::experimental::Tensor et1;
+  paddle::Tensor et1;
   phi::DenseTensorMeta meta =
       phi::DenseTensorMeta(phi::DataType::FLOAT32, phi::make_ddim({1, 2}));
   std::shared_ptr<phi::DenseTensor> dt = std::make_shared<phi::DenseTensor>(
@@ -50,7 +50,7 @@ TEST(TensorWrapper, Basic) {
   CHECK_EQ(egr::EagerUtils::OutRankInfo(recover_et1).second,
            egr::EagerUtils::OutRankInfo(et1).second);
   VLOG(6) << "Test reconstruct";
-  paddle::experimental::Tensor et2;
+  paddle::Tensor et2;
   phi::DenseTensorMeta meta2 =
       phi::DenseTensorMeta(phi::DataType::FLOAT32, phi::make_ddim({1, 2}));
   std::shared_ptr<phi::DenseTensor> dt2 = std::make_shared<phi::DenseTensor>(
@@ -78,7 +78,7 @@ TEST(TensorWrapper, Basic) {
   CHECK_EQ(egr::EagerUtils::OutRankInfo(recover_et2).second,
            egr::EagerUtils::OutRankInfo(et2).second);
   // Test Raw recover
-  paddle::experimental::Tensor et3;
+  paddle::Tensor et3;
   auto tw2 = egr::TensorWrapper(et3);
   CHECK(tw2.recover().initialized() == false);
 }

paddle/fluid/eager/tests/performance_tests/benchmark_eager_cpu.cc

@@ -50,13 +50,12 @@ TEST(Benchmark, EagerScaleCPU) {
 
   for (const std::string& mode : {"Accuracy", "Performance"}) {
     paddle::framework::DDim ddim = phi::make_ddim({2, 4, 4, 4});
-    paddle::experimental::Tensor tensor =
-        CreateTensorWithValue(ddim,
-                              paddle::platform::CPUPlace(),
-                              phi::DataType::FLOAT32,
-                              phi::DataLayout::NCHW,
-                              5.0,
-                              true);
+    paddle::Tensor tensor = CreateTensorWithValue(ddim,
+                                                  paddle::platform::CPUPlace(),
+                                                  phi::DataType::FLOAT32,
+                                                  phi::DataLayout::NCHW,
+                                                  5.0,
+                                                  true);
     RetainGradForTensor(tensor);
 
     if (mode == "Accuracy") {
@@ -90,23 +89,21 @@ TEST(Benchmark, EagerMatmulCPU) {
 
   for (const std::string& mode : {"Accuracy", "Performance"}) {
     paddle::framework::DDim ddimX = phi::make_ddim({2, 2});
-    paddle::experimental::Tensor X =
-        CreateTensorWithValue(ddimX,
-                              paddle::platform::CPUPlace(),
-                              phi::DataType::FLOAT32,
-                              phi::DataLayout::NCHW,
-                              1.0,
-                              true);
+    paddle::Tensor X = CreateTensorWithValue(ddimX,
+                                             paddle::platform::CPUPlace(),
+                                             phi::DataType::FLOAT32,
+                                             phi::DataLayout::NCHW,
+                                             1.0,
+                                             true);
     RetainGradForTensor(X);
 
     paddle::framework::DDim ddimY = phi::make_ddim({2, 2});
-    paddle::experimental::Tensor Y =
-        CreateTensorWithValue(ddimY,
-                              paddle::platform::CPUPlace(),
-                              phi::DataType::FLOAT32,
-                              phi::DataLayout::NCHW,
-                              2.0,
-                              true);
+    paddle::Tensor Y = CreateTensorWithValue(ddimY,
+                                             paddle::platform::CPUPlace(),
+                                             phi::DataType::FLOAT32,
+                                             phi::DataLayout::NCHW,
+                                             2.0,
+                                             true);
     RetainGradForTensor(Y);
 
     if (mode == "Accuracy") {
@@ -142,23 +139,21 @@ TEST(Benchmark, EagerIntermediateMatmulCPU) {
 
   for (const std::string& mode : {"Accuracy", "Performance"}) {
     paddle::framework::DDim ddimX = phi::make_ddim({2, 2});
-    paddle::experimental::Tensor X =
-        CreateTensorWithValue(ddimX,
-                              paddle::platform::CPUPlace(),
-                              phi::DataType::FLOAT32,
-                              phi::DataLayout::NCHW,
-                              1.0,
-                              true);
+    paddle::Tensor X = CreateTensorWithValue(ddimX,
+                                             paddle::platform::CPUPlace(),
+                                             phi::DataType::FLOAT32,
+                                             phi::DataLayout::NCHW,
+                                             1.0,
+                                             true);
     RetainGradForTensor(X);
 
     paddle::framework::DDim ddimY = phi::make_ddim({2, 2});
-    paddle::experimental::Tensor Y =
-        CreateTensorWithValue(ddimY,
-                              paddle::platform::CPUPlace(),
-                              phi::DataType::FLOAT32,
-                              phi::DataLayout::NCHW,
-                              2.0,
-                              true);
+    paddle::Tensor Y = CreateTensorWithValue(ddimY,
+                                             paddle::platform::CPUPlace(),
+                                             phi::DataType::FLOAT32,
+                                             phi::DataLayout::NCHW,
+                                             2.0,
+                                             true);
     RetainGradForTensor(Y);
 
     if (mode == "Accuracy") {
@@ -194,36 +189,33 @@ TEST(Benchmark, EagerIntermediateMLPCPU) {
 
   for (const std::string& mode : {"Accuracy", "Performance"}) {
     paddle::framework::DDim ddimX = phi::make_ddim({MLP_M, MLP_N});
-    paddle::experimental::Tensor X =
-        CreateTensorWithValue(ddimX,
-                              paddle::platform::CPUPlace(),
-                              phi::DataType::FLOAT32,
-                              phi::DataLayout::NCHW,
-                              MLP_X_VAL,
-                              true);
+    paddle::Tensor X = CreateTensorWithValue(ddimX,
+                                             paddle::platform::CPUPlace(),
+                                             phi::DataType::FLOAT32,
+                                             phi::DataLayout::NCHW,
+                                             MLP_X_VAL,
+                                             true);
     RetainGradForTensor(X);
 
-    std::vector<paddle::experimental::Tensor> Ws;
-    std::vector<paddle::experimental::Tensor> Bs;
+    std::vector<paddle::Tensor> Ws;
+    std::vector<paddle::Tensor> Bs;
     for (size_t i = 0; i < MLP_NUM_LINEAR; i++) {
       paddle::framework::DDim ddimW = phi::make_ddim({MLP_N, MLP_K});
-      paddle::experimental::Tensor W =
-          CreateTensorWithValue(ddimW,
-                                paddle::platform::CPUPlace(),
-                                phi::DataType::FLOAT32,
-                                phi::DataLayout::NCHW,
-                                MLP_W_VAL,
-                                true);
+      paddle::Tensor W = CreateTensorWithValue(ddimW,
+                                               paddle::platform::CPUPlace(),
+                                               phi::DataType::FLOAT32,
+                                               phi::DataLayout::NCHW,
+                                               MLP_W_VAL,
+                                               true);
       RetainGradForTensor(W);
 
       paddle::framework::DDim ddimB = phi::make_ddim({MLP_K});
-      paddle::experimental::Tensor B =
-          CreateTensorWithValue(ddimB,
-                                paddle::platform::CPUPlace(),
-                                phi::DataType::FLOAT32,
-                                phi::DataLayout::NCHW,
-                                MLP_B_VAL,
-                                true);
+      paddle::Tensor B = CreateTensorWithValue(ddimB,
+                                               paddle::platform::CPUPlace(),
+                                               phi::DataType::FLOAT32,
+                                               phi::DataLayout::NCHW,
+                                               MLP_B_VAL,
+                                               true);
       RetainGradForTensor(B);
 
       Ws.emplace_back(std::move(W));

paddle/fluid/eager/tests/performance_tests/benchmark_eager_cuda.cc

@@ -50,13 +50,12 @@ TEST(Benchmark, EagerScaleCUDA) {
 
   for (const std::string& mode : {"Accuracy", "WarmUp", "Performance"}) {
     paddle::framework::DDim ddim = phi::make_ddim({2, 4, 4, 4});
-    paddle::experimental::Tensor tensor =
-        CreateTensorWithValue(ddim,
-                              paddle::platform::CUDAPlace(),
-                              phi::DataType::FLOAT32,
-                              phi::DataLayout::NCHW,
-                              5.0 /*value*/,
-                              true /*is_leaf*/);
+    paddle::Tensor tensor = CreateTensorWithValue(ddim,
+                                                  paddle::platform::CUDAPlace(),
+                                                  phi::DataType::FLOAT32,
+                                                  phi::DataLayout::NCHW,
+                                                  5.0 /*value*/,
+                                                  true /*is_leaf*/);
     RetainGradForTensor(tensor);
 
     if (mode == "Accuracy") {
@@ -92,23 +91,21 @@ TEST(Benchmark, EagerMatmulCUDA) {
 
   for (const std::string& mode : {"Accuracy", "WarmUp", "Performance"}) {
     paddle::framework::DDim ddimX = phi::make_ddim({2, 2});
-    paddle::experimental::Tensor X =
-        CreateTensorWithValue(ddimX,
-                              paddle::platform::CUDAPlace(),
-                              phi::DataType::FLOAT32,
-                              phi::DataLayout::NCHW,
-                              1.0,
-                              true);
+    paddle::Tensor X = CreateTensorWithValue(ddimX,
+                                             paddle::platform::CUDAPlace(),
+                                             phi::DataType::FLOAT32,
+                                             phi::DataLayout::NCHW,
+                                             1.0,
+                                             true);
     RetainGradForTensor(X);
 
     paddle::framework::DDim ddimY = phi::make_ddim({2, 2});
-    paddle::experimental::Tensor Y =
-        CreateTensorWithValue(ddimY,
-                              paddle::platform::CUDAPlace(),
-                              phi::DataType::FLOAT32,
-                              phi::DataLayout::NCHW,
-                              2.0,
-                              true);
+    paddle::Tensor Y = CreateTensorWithValue(ddimY,
+                                             paddle::platform::CUDAPlace(),
+                                             phi::DataType::FLOAT32,
+                                             phi::DataLayout::NCHW,
+                                             2.0,
+                                             true);
     RetainGradForTensor(Y);
 
     if (mode == "Accuracy") {
@@ -148,23 +145,21 @@ TEST(Benchmark, EagerIntermediateMatmulCUDA) {
 
   for (const std::string& mode : {"Accuracy", "WarmUp", "Performance"}) {
     paddle::framework::DDim ddimX = phi::make_ddim({2, 2});
-    paddle::experimental::Tensor X =
-        CreateTensorWithValue(ddimX,
-                              paddle::platform::CUDAPlace(),
-                              phi::DataType::FLOAT32,
-                              phi::DataLayout::NCHW,
-                              1.0,
-                              true);
+    paddle::Tensor X = CreateTensorWithValue(ddimX,
+                                             paddle::platform::CUDAPlace(),
+                                             phi::DataType::FLOAT32,
+                                             phi::DataLayout::NCHW,
+                                             1.0,
+                                             true);
     RetainGradForTensor(X);
 
     paddle::framework::DDim ddimY = phi::make_ddim({2, 2});
-    paddle::experimental::Tensor Y =
-        CreateTensorWithValue(ddimY,
-                              paddle::platform::CUDAPlace(),
-                              phi::DataType::FLOAT32,
-                              phi::DataLayout::NCHW,
-                              2.0,
-                              true);
+    paddle::Tensor Y = CreateTensorWithValue(ddimY,
+                                             paddle::platform::CUDAPlace(),
+                                             phi::DataType::FLOAT32,
+                                             phi::DataLayout::NCHW,
+                                             2.0,
+                                             true);
     RetainGradForTensor(Y);
 
     if (mode == "Accuracy") {
@@ -204,36 +199,33 @@ TEST(Benchmark, EagerIntermediateMLPCUDA) {
 
   for (const std::string& mode : {"Accuracy", "WarmUp", "Performance"}) {
     paddle::framework::DDim ddimX = phi::make_ddim({MLP_M, MLP_N});
-    paddle::experimental::Tensor X =
-        CreateTensorWithValue(ddimX,
-                              paddle::platform::CUDAPlace(),
-                              phi::DataType::FLOAT32,
-                              phi::DataLayout::NCHW,
-                              MLP_X_VAL,
-                              true);
+    paddle::Tensor X = CreateTensorWithValue(ddimX,
+                                             paddle::platform::CUDAPlace(),
+                                             phi::DataType::FLOAT32,
+                                             phi::DataLayout::NCHW,
+                                             MLP_X_VAL,
+                                             true);
     RetainGradForTensor(X);
 
-    std::vector<paddle::experimental::Tensor> Ws;
-    std::vector<paddle::experimental::Tensor> Bs;
+    std::vector<paddle::Tensor> Ws;
+    std::vector<paddle::Tensor> Bs;
     for (size_t i = 0; i < MLP_NUM_LINEAR; i++) {
       paddle::framework::DDim ddimW = phi::make_ddim({MLP_N, MLP_K});
-      paddle::experimental::Tensor W =
-          CreateTensorWithValue(ddimW,
-                                paddle::platform::CUDAPlace(),
-                                phi::DataType::FLOAT32,
-                                phi::DataLayout::NCHW,
-                                MLP_W_VAL,
-                                true);
+      paddle::Tensor W = CreateTensorWithValue(ddimW,
+                                               paddle::platform::CUDAPlace(),
+                                               phi::DataType::FLOAT32,
+                                               phi::DataLayout::NCHW,
+                                               MLP_W_VAL,
+                                               true);
       RetainGradForTensor(W);
 
       paddle::framework::DDim ddimB = phi::make_ddim({MLP_K});
-      paddle::experimental::Tensor B =
-          CreateTensorWithValue(ddimB,
-                                paddle::platform::CUDAPlace(),
-                                phi::DataType::FLOAT32,
-                                phi::DataLayout::NCHW,
-                                MLP_B_VAL,
-                                true);
+      paddle::Tensor B = CreateTensorWithValue(ddimB,
+                                               paddle::platform::CUDAPlace(),
+                                               phi::DataType::FLOAT32,
+                                               phi::DataLayout::NCHW,
+                                               MLP_B_VAL,
+                                               true);
       RetainGradForTensor(B);
 
       Ws.emplace_back(std::move(W));

paddle/fluid/eager/tests/performance_tests/benchmark_utils.cc

@@ -44,9 +44,8 @@ namespace egr {
 /* --------------------- */
 /* ---- Eager Scale ---- */
 /* --------------------- */
-void benchmark_eager_scale(const paddle::experimental::Tensor& tensor,
-                           bool accuracy_check) {
-  paddle::experimental::Tensor input_tensor = tensor;
+void benchmark_eager_scale(const paddle::Tensor& tensor, bool accuracy_check) {
+  paddle::Tensor input_tensor = tensor;
   float scale = 2.0;
   float bias = 3.0;
 
@@ -59,7 +58,7 @@ void benchmark_eager_scale(const paddle::experimental::Tensor& tensor,
                               true /*trace_backward*/);
   }
 
-  std::vector<paddle::experimental::Tensor> target_tensors = {input_tensor};
+  std::vector<paddle::Tensor> target_tensors = {input_tensor};
   Backward(target_tensors, {});
 
   if (accuracy_check) {
@@ -70,17 +69,17 @@ void benchmark_eager_scale(const paddle::experimental::Tensor& tensor,
   }
 }
 
-void benchmark_eager_matmul(const paddle::experimental::Tensor& X,
-                            const paddle::experimental::Tensor& Y,
+void benchmark_eager_matmul(const paddle::Tensor& X,
+                            const paddle::Tensor& Y,
                             bool accuracy_check) {
-  paddle::experimental::Tensor input_tensor0 = X;
+  paddle::Tensor input_tensor0 = X;
 
   size_t max_num_runs = accuracy_check ? 2 : max_num_benchmark_runs;
   for (size_t i = 0; i < max_num_runs; i++) {
     input_tensor0 = matmul_ad_func(input_tensor0, Y, false, false);
   }
 
-  std::vector<paddle::experimental::Tensor> target_tensors = {input_tensor0};
+  std::vector<paddle::Tensor> target_tensors = {input_tensor0};
   Backward(target_tensors, {});
 
   if (accuracy_check) {
@@ -95,10 +94,10 @@ void benchmark_eager_matmul(const paddle::experimental::Tensor& X,
 /* ----------------------------------- */
 /* ---- Eager Intermediate Matmul ---- */
 /* ----------------------------------- */
-void benchmark_eager_intermediate_matmul(const paddle::experimental::Tensor& X,
-                                         const paddle::experimental::Tensor& Y,
+void benchmark_eager_intermediate_matmul(const paddle::Tensor& X,
+                                         const paddle::Tensor& Y,
                                          bool accuracy_check) {
-  paddle::experimental::Tensor input_tensor0 = X;
+  paddle::Tensor input_tensor0 = X;
 
   size_t max_num_runs = accuracy_check ? 2 : max_num_benchmark_runs;
   for (size_t i = 0; i < max_num_runs; i++) {
@@ -106,7 +105,7 @@ void benchmark_eager_intermediate_matmul(const paddle::experimental::Tensor& X,
         input_tensor0, Y, {{"trans_x", false}, {"trans_y", false}});
   }
 
-  std::vector<paddle::experimental::Tensor> target_tensors = {input_tensor0};
+  std::vector<paddle::Tensor> target_tensors = {input_tensor0};
   Backward(target_tensors, {});
 
   if (accuracy_check) {
@@ -121,24 +120,23 @@ void benchmark_eager_intermediate_matmul(const paddle::experimental::Tensor& X,
 /* -------------------------------- */
 /* ---- Eager Intermediate MLP ---- */
 /* -------------------------------- */
-void benchmark_eager_intermediate_mlp(
-    const paddle::experimental::Tensor& X,
-    const std::vector<paddle::experimental::Tensor>& Ws,
-    const std::vector<paddle::experimental::Tensor>& Bs,
-    bool accuracy_check) {
-  paddle::experimental::Tensor input0 = X;
+void benchmark_eager_intermediate_mlp(const paddle::Tensor& X,
+                                      const std::vector<paddle::Tensor>& Ws,
+                                      const std::vector<paddle::Tensor>& Bs,
+                                      bool accuracy_check) {
+  paddle::Tensor input0 = X;
 
   for (size_t i = 0; i < MLP_NUM_LINEAR; i++) {
-    paddle::experimental::Tensor Out = matmul_v2_dygraph_function(
+    paddle::Tensor Out = matmul_v2_dygraph_function(
         input0, Ws[i], {{"trans_x", false}, {"trans_y", false}});
 
     input0 = elementwise_add_dygraph_function(Out, Bs[i], {});
   }
 
-  paddle::experimental::Tensor Out =
+  paddle::Tensor Out =
       reduce_sum_dygraph_function(input0, {{"reduce_all", true}});
 
-  std::vector<paddle::experimental::Tensor> target_tensors = {Out};
+  std::vector<paddle::Tensor> target_tensors = {Out};
   Backward(target_tensors, {});
 
   if (accuracy_check) {

paddle/fluid/eager/tests/performance_tests/benchmark_utils.h

@@ -48,23 +48,22 @@ inline std::unordered_map<std::string, float> compute_mlp_expected_results() {
 }
 
 /* ---- Eager Scale ---- */
-void benchmark_eager_scale(const paddle::experimental::Tensor& tensor,
+void benchmark_eager_scale(const paddle::Tensor& tensor,
                            bool accuracy_check = false);
 
 /* ---- Eager MatMul ---- */
-void benchmark_eager_matmul(const paddle::experimental::Tensor& X,
-                            const paddle::experimental::Tensor& Y,
+void benchmark_eager_matmul(const paddle::Tensor& X,
+                            const paddle::Tensor& Y,
                             bool accuracy_check = false);
 
-void benchmark_eager_intermediate_matmul(const paddle::experimental::Tensor& X,
-                                         const paddle::experimental::Tensor& Y,
+void benchmark_eager_intermediate_matmul(const paddle::Tensor& X,
+                                         const paddle::Tensor& Y,
                                          bool accuracy_check = false);
 
-void benchmark_eager_intermediate_mlp(
-    const paddle::experimental::Tensor& X,
-    const std::vector<paddle::experimental::Tensor>& Ws,
-    const std::vector<paddle::experimental::Tensor>& Bs,
-    bool accuracy_check = false);
+void benchmark_eager_intermediate_mlp(const paddle::Tensor& X,
+                                      const std::vector<paddle::Tensor>& Ws,
+                                      const std::vector<paddle::Tensor>& Bs,
+                                      bool accuracy_check = false);
 
 }  // namespace egr
 

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

@@ -42,7 +42,7 @@ TEST(Backward, SingleNodeEmptyGrad) {
   paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32});
 
   // Create Target Tensor
-  paddle::experimental::Tensor target_tensor =
+  paddle::Tensor target_tensor =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -50,7 +50,7 @@ TEST(Backward, SingleNodeEmptyGrad) {
                                            1.0 /*value*/,
                                            false /*is_leaf*/);
 
-  paddle::experimental::Tensor leaf_tensor;
+  paddle::Tensor leaf_tensor;
   {
     // Create Scale Node
     auto node0_ptr = std::make_shared<GradNodeScale>(1, 1);
@@ -77,7 +77,7 @@ TEST(Backward, SingleNodeEmptyGrad) {
 
     node0_ptr->SetGradOutMeta({leaf_tensor}, 0);
   }
-  std::vector<paddle::experimental::Tensor> outs = {target_tensor};
+  std::vector<paddle::Tensor> outs = {target_tensor};
   // Run Backward
   Backward(outs, {});
 
@@ -90,11 +90,11 @@ TEST(Backward, SingleNodeCustomGrad) {
   eager_test::InitEnv(paddle::platform::CPUPlace());
 
   // Prepare Inputs
-  std::vector<paddle::experimental::Tensor> target_tensors;
+  std::vector<paddle::Tensor> target_tensors;
   paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32});
 
   // Create Target Tensor
-  paddle::experimental::Tensor tensor =
+  paddle::Tensor tensor =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -103,9 +103,9 @@ TEST(Backward, SingleNodeCustomGrad) {
                                            false /*is_leaf*/);
   target_tensors.emplace_back(std::move(tensor));
 
-  std::vector<paddle::experimental::Tensor> grad_tensors;
+  std::vector<paddle::Tensor> grad_tensors;
   // Create Grad Tensor
-  paddle::experimental::Tensor grad_tensor =
+  paddle::Tensor grad_tensor =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -114,7 +114,7 @@ TEST(Backward, SingleNodeCustomGrad) {
                                            false /*is_leaf*/);
   grad_tensors.emplace_back(std::move(grad_tensor));
 
-  paddle::experimental::Tensor leaf_tensor;
+  paddle::Tensor leaf_tensor;
   {
     // Create Scale Node
     auto node0_ptr = std::make_shared<GradNodeScale>(1, 1);
@@ -162,11 +162,11 @@ TEST(Backward, LinearNodes) {
   eager_test::InitEnv(paddle::platform::CPUPlace());
 
   // Prepare Inputs
-  std::vector<paddle::experimental::Tensor> target_tensors;
+  std::vector<paddle::Tensor> target_tensors;
   paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32});
 
   // Create Target Tensor
-  paddle::experimental::Tensor tensor =
+  paddle::Tensor tensor =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -175,7 +175,7 @@ TEST(Backward, LinearNodes) {
                                            false /*is_leaf*/);
   target_tensors.emplace_back(std::move(tensor));
 
-  paddle::experimental::Tensor leaf_tensor;
+  paddle::Tensor leaf_tensor;
   {
     // Create Node0
     auto node0_ptr = std::make_shared<GradNodeScale>(1, 1);
@@ -199,7 +199,7 @@ TEST(Backward, LinearNodes) {
     auto_grad_meta->SetSingleOutRankWithSlot(0, 0);
     auto_grad_meta->SetStopGradient(false);
     // Connect Node0 -> Node1 via Edge
-    auto tmp_tensor = paddle::experimental::Tensor();
+    auto tmp_tensor = paddle::Tensor();
     auto* meta0 = EagerUtils::autograd_meta(&tmp_tensor);
     meta0->SetStopGradient(false);
     meta0->SetSingleOutRankWithSlot(0, 0);
@@ -241,15 +241,15 @@ TEST(Backward, WithAccumulation) {
   paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32});
 
   // Create Target Tensor
-  std::vector<paddle::experimental::Tensor> target_tensors;
-  paddle::experimental::Tensor tensor0 =
+  std::vector<paddle::Tensor> target_tensors;
+  paddle::Tensor tensor0 =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
                                            phi::DataLayout::NCHW,
                                            1.0 /*value*/,
                                            false /*is_leaf*/);
-  paddle::experimental::Tensor tensor1 =
+  paddle::Tensor tensor1 =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -260,15 +260,15 @@ TEST(Backward, WithAccumulation) {
   target_tensors.emplace_back(std::move(tensor1));
 
   // Create Grad Tensor
-  std::vector<paddle::experimental::Tensor> grad_tensors;
-  paddle::experimental::Tensor grad_tensor0 =
+  std::vector<paddle::Tensor> grad_tensors;
+  paddle::Tensor grad_tensor0 =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
                                            phi::DataLayout::NCHW,
                                            5.0 /*value*/,
                                            false /*is_leaf*/);
-  paddle::experimental::Tensor grad_tensor1 =
+  paddle::Tensor grad_tensor1 =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -278,7 +278,7 @@ TEST(Backward, WithAccumulation) {
   grad_tensors.emplace_back(std::move(grad_tensor0));
   grad_tensors.emplace_back(std::move(grad_tensor1));
 
-  paddle::experimental::Tensor leaf_tensor;
+  paddle::Tensor leaf_tensor;
   {
     // Create Node0
     auto node0_ptr = std::make_shared<GradNodeScale>(1, 1);
@@ -309,7 +309,7 @@ TEST(Backward, WithAccumulation) {
     auto_grad_meta1->SetStopGradient(false);
 
     // Connect Node0 -> Node2 via Edge
-    auto tmp_tensor0 = paddle::experimental::Tensor();
+    auto tmp_tensor0 = paddle::Tensor();
     auto* meta0 = EagerUtils::autograd_meta(&tmp_tensor0);
     meta0->SetStopGradient(false);
     meta0->SetSingleOutRankWithSlot(0, 0);
@@ -317,7 +317,7 @@ TEST(Backward, WithAccumulation) {
     node0_ptr->SetGradOutMeta(tmp_tensor0, 0);
 
     // Connect Node1 -> Node2 via Edge
-    auto tmp_tensor1 = paddle::experimental::Tensor();
+    auto tmp_tensor1 = paddle::Tensor();
     auto* meta1 = EagerUtils::autograd_meta(&tmp_tensor1);
     meta1->SetStopGradient(false);
     meta1->SetSingleOutRankWithSlot(0, 0);

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

@@ -35,10 +35,10 @@ namespace egr {
 TEST(CrossBatchAccumulation, SingleScaleNode) {
   eager_test::InitEnv(paddle::platform::CPUPlace());
 
-  std::vector<paddle::experimental::Tensor> target_tensors;
+  std::vector<paddle::Tensor> target_tensors;
   paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32});
 
-  paddle::experimental::Tensor tensor =
+  paddle::Tensor tensor =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -46,9 +46,9 @@ TEST(CrossBatchAccumulation, SingleScaleNode) {
                                            1.0 /*value*/,
                                            false /*is_leaf*/);
   target_tensors.emplace_back(std::move(tensor));
-  paddle::experimental::Tensor& target_tensor = target_tensors[0];
+  paddle::Tensor& target_tensor = target_tensors[0];
 
-  paddle::experimental::Tensor leaf_tensor = paddle::experimental::Tensor();
+  paddle::Tensor leaf_tensor = paddle::Tensor();
 
   auto scale_node_ptr = std::make_shared<GradNodeScale>(1, 1);
   scale_node_ptr->SetAttributes_scale(5.0 /*scale*/);

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

@@ -38,7 +38,7 @@ TEST(EagerUtils, AutoGradMeta) {
           .get(),
       meta);
   dt0->mutable_data<float>(paddle::platform::CPUPlace())[0] = 10.0;
-  paddle::experimental::Tensor et0 = paddle::experimental::Tensor(dt0);
+  paddle::Tensor et0 = paddle::Tensor(dt0);
 
   std::shared_ptr<phi::DenseTensor> dt1 = std::make_shared<phi::DenseTensor>(
       std::make_unique<paddle::experimental::DefaultAllocator>(
@@ -46,7 +46,7 @@ TEST(EagerUtils, AutoGradMeta) {
           .get(),
       meta);
   dt1->mutable_data<float>(paddle::platform::CPUPlace())[0] = 20.0;
-  paddle::experimental::Tensor et1 = paddle::experimental::Tensor(dt1);
+  paddle::Tensor et1 = paddle::Tensor(dt1);
 
   // unsafe_autograd_meta()
   // autograd_meta()
@@ -58,7 +58,7 @@ TEST(EagerUtils, AutoGradMeta) {
   CHECK_NOTNULL(unsafe_autograd_meta_after);
 
   // NOTE: Since autograd_meta will be copied make sure it's not null
-  std::vector<paddle::experimental::Tensor> ets = {et0, et1};
+  std::vector<paddle::Tensor> ets = {et0, et1};
   auto test_node = std::make_shared<eager_test::GradTestNode>();
 
   std::vector<AutogradMeta*> autograd_metas = EagerUtils::autograd_meta(&ets);
@@ -103,11 +103,10 @@ TEST(EagerUtils, AutoGradMeta) {
 }
 
 template <typename T>
-paddle::experimental::Tensor CreateTestCPUTensor(
-    T val, const paddle::framework::DDim& ddim) {
+paddle::Tensor CreateTestCPUTensor(T val, const paddle::framework::DDim& ddim) {
   phi::DenseTensorMeta meta =
       phi::DenseTensorMeta(phi::DataType::FLOAT32, ddim);
-  paddle::experimental::Tensor tensor;
+  paddle::Tensor tensor;
   std::shared_ptr<phi::DenseTensor> dt = std::make_shared<phi::DenseTensor>(
       std::make_unique<paddle::experimental::DefaultAllocator>(
           paddle::platform::CPUPlace())
@@ -189,8 +188,8 @@ TEST(EagerUtils, TrySyncToVar) {
 
 TEST(EagerUtils, TrySyncToVars) {
   paddle::framework::DDim ddim = phi::make_ddim({2, 4, 4, 4});
-  std::vector<paddle::experimental::Tensor> tensors = {
-      CreateTestCPUTensor(1.0f, ddim), CreateTestCPUTensor(2.0f, ddim)};
+  std::vector<paddle::Tensor> tensors = {CreateTestCPUTensor(1.0f, ddim),
+                                         CreateTestCPUTensor(2.0f, ddim)};
 
   std::vector<std::shared_ptr<egr::EagerVariable>> var_bases =
       egr::EagerUtils::TrySyncToVars(tensors);
@@ -231,7 +230,7 @@ TEST(EagerUtils, CreateVars) {
 
 TEST(EagerUtils, GetGradAccumulationNode) {
   VLOG(6) << "Check GetGradAccumulationNode";
-  paddle::experimental::Tensor t0("test_tensor");
+  paddle::Tensor t0("test_tensor");
   ASSERT_EQ(egr::EagerUtils::GetGradAccumulationNode(t0), nullptr);
   auto autograd_ptr0 = egr::EagerUtils::autograd_meta(&t0);
   autograd_ptr0->SetStopGradient(true);
@@ -252,9 +251,8 @@ TEST(EagerUtils, GetGradAccumulationNode) {
 }
 
 TEST(EagerUtils, FillZeroForEmptyOptionalGradInput) {
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
-      grads = {std::vector<paddle::experimental::Tensor>(1)};
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
+      grads = {std::vector<paddle::Tensor>(1)};
   paddle::small_vector<std::vector<GradSlotMeta>, egr::kSlotSmallVectorSize>
       slot_metas = {std::vector<GradSlotMeta>(1)};
 

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

@@ -35,11 +35,11 @@ TEST(Forward, SingleNode) {
   eager_test::InitEnv(paddle::platform::CPUPlace());
 
   // Prepare Inputs
-  std::vector<paddle::experimental::Tensor> target_tensors;
+  std::vector<paddle::Tensor> target_tensors;
   paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32});
 
   // Create Target Tensor
-  paddle::experimental::Tensor t =
+  paddle::Tensor t =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -47,13 +47,13 @@ TEST(Forward, SingleNode) {
                                            5.0 /*value*/,
                                            false /*is_leaf*/);
   target_tensors.emplace_back(std::move(t));
-  paddle::experimental::Tensor& tensor = target_tensors[0];
+  paddle::Tensor& tensor = target_tensors[0];
   EagerUtils::autograd_meta(&tensor)->SetStopGradient(false);
 
   // Run Forward
   float scale = 2.0;
   float bias = 3.0;
-  paddle::experimental::Tensor out = egr::scale(
+  paddle::Tensor out = egr::scale(
       tensor, scale, bias, true /*bias_after_scale*/, true /*trace_backward*/);
 
   // Examine Forward Output
@@ -85,11 +85,11 @@ TEST(Forward, LinearNodes) {
   eager_test::InitEnv(paddle::platform::CPUPlace());
 
   // Prepare Inputs
-  std::vector<paddle::experimental::Tensor> target_tensors;
+  std::vector<paddle::Tensor> target_tensors;
   paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32});
 
   // Create Target Tensor
-  paddle::experimental::Tensor t =
+  paddle::Tensor t =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -97,22 +97,22 @@ TEST(Forward, LinearNodes) {
                                            5.0 /*value*/,
                                            false /*is_leaf*/);
   target_tensors.emplace_back(std::move(t));
-  paddle::experimental::Tensor& tensor = target_tensors[0];
+  paddle::Tensor& tensor = target_tensors[0];
   EagerUtils::autograd_meta(&tensor)->SetStopGradient(false);
 
   // Run Forward Node 0
   float scale0 = 2.0;
   float bias0 = 3.0;
-  paddle::experimental::Tensor out0 = egr::scale(tensor,
-                                                 scale0,
-                                                 bias0,
-                                                 true /*bias_after_scale*/,
-                                                 true /*trace_backward*/);
+  paddle::Tensor out0 = egr::scale(tensor,
+                                   scale0,
+                                   bias0,
+                                   true /*bias_after_scale*/,
+                                   true /*trace_backward*/);
 
   // Run Forward Node 1
   float scale1 = 5.0;
   float bias1 = 10.0;
-  paddle::experimental::Tensor out1 = egr::scale(
+  paddle::Tensor out1 = egr::scale(
       out0, scale1, bias1, true /*bias_after_scale*/, true /*trace_backward*/);
 
   // Examine Forward Output 0
@@ -171,11 +171,11 @@ TEST(Forward, BranchedNodes) {
   eager_test::InitEnv(paddle::platform::CPUPlace());
 
   // Prepare Inputs
-  std::vector<paddle::experimental::Tensor> target_tensors;
+  std::vector<paddle::Tensor> target_tensors;
   paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32});
 
   // Create Target Tensor
-  paddle::experimental::Tensor t =
+  paddle::Tensor t =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -183,28 +183,28 @@ TEST(Forward, BranchedNodes) {
                                            5.0 /*value*/,
                                            false /*is_leaf*/);
   target_tensors.emplace_back(std::move(t));
-  paddle::experimental::Tensor& tensor = target_tensors[0];
+  paddle::Tensor& tensor = target_tensors[0];
   EagerUtils::autograd_meta(&tensor)->SetStopGradient(false);
 
   // Run Forward Node 0
   float scale0 = 2.0;
   float bias0 = 3.0;
-  paddle::experimental::Tensor out0 = egr::scale(tensor,
-                                                 scale0,
-                                                 bias0,
-                                                 true /*bias_after_scale*/,
-                                                 true /*trace_backward*/);
+  paddle::Tensor out0 = egr::scale(tensor,
+                                   scale0,
+                                   bias0,
+                                   true /*bias_after_scale*/,
+                                   true /*trace_backward*/);
 
   // Run Forward Node 1
   float scale1 = 5.0;
   float bias1 = 10.0;
-  paddle::experimental::Tensor out1 = egr::scale(
+  paddle::Tensor out1 = egr::scale(
       out0, scale1, bias1, true /*bias_after_scale*/, true /*trace_backward*/);
 
   // Run Forward Node 2
   float scale2 = 10.0;
   float bias2 = 20.0;
-  paddle::experimental::Tensor out2 = egr::scale(
+  paddle::Tensor out2 = egr::scale(
       out0, scale2, bias2, true /*bias_after_scale*/, true /*trace_backward*/);
 
   // Examine Forward Output 0

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

@@ -44,21 +44,21 @@ TEST(Generated, Sigmoid) {
   // 1. Prepare Input
   paddle::framework::DDim ddim = phi::make_ddim({2, 4, 4, 4});
   VLOG(6) << "Make Dim";
-  paddle::experimental::Tensor tensor =
+  paddle::Tensor tensor =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
                                            phi::DataLayout::NCHW,
                                            0.0,
                                            true);
-  VLOG(6) << "Make paddle::experimental::Tensor";
+  VLOG(6) << "Make paddle::Tensor";
   egr_utils_api::RetainGradForTensor(tensor);
   VLOG(6) << "Retain Grad for Tensor";
   auto output_tensor = sigmoid_dygraph_function(tensor, {});
   VLOG(6) << "Run Backward";
   eager_test::CompareTensorWithValue<float>(output_tensor, 0.5);
 
-  std::vector<paddle::experimental::Tensor> target_tensors = {output_tensor};
+  std::vector<paddle::Tensor> target_tensors = {output_tensor};
   VLOG(6) << "Runing Backward";
   Backward(target_tensors, {});
 
@@ -75,7 +75,7 @@ TEST(Generated, Matmul_v2) {
 
   // 1. Prepare Input
   paddle::framework::DDim ddimX = phi::make_ddim({4, 16});
-  paddle::experimental::Tensor X =
+  paddle::Tensor X =
       egr_utils_api::CreateTensorWithValue(ddimX,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -85,7 +85,7 @@ TEST(Generated, Matmul_v2) {
   egr_utils_api::RetainGradForTensor(X);
 
   paddle::framework::DDim ddimY = phi::make_ddim({16, 20});
-  paddle::experimental::Tensor Y =
+  paddle::Tensor Y =
       egr_utils_api::CreateTensorWithValue(ddimY,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -99,7 +99,7 @@ TEST(Generated, Matmul_v2) {
 
   eager_test::CompareTensorWithValue<float>(output_tensor, 96);
 
-  std::vector<paddle::experimental::Tensor> target_tensors = {output_tensor};
+  std::vector<paddle::Tensor> target_tensors = {output_tensor};
   Backward(target_tensors, {});
 
   eager_test::CompareGradTensorWithValue<float>(X, 2.0 * 20);
@@ -115,7 +115,7 @@ TEST(Generated, ElementwiseAdd) {
 
   // 1. Prepare Input
   paddle::framework::DDim ddimX = phi::make_ddim({4, 16});
-  paddle::experimental::Tensor X =
+  paddle::Tensor X =
       egr_utils_api::CreateTensorWithValue(ddimX,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -125,7 +125,7 @@ TEST(Generated, ElementwiseAdd) {
   egr_utils_api::RetainGradForTensor(X);
 
   paddle::framework::DDim ddimY = phi::make_ddim({4, 16});
-  paddle::experimental::Tensor Y =
+  paddle::Tensor Y =
       egr_utils_api::CreateTensorWithValue(ddimY,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -138,7 +138,7 @@ TEST(Generated, ElementwiseAdd) {
 
   eager_test::CompareTensorWithValue<float>(output_tensor, 5);
 
-  std::vector<paddle::experimental::Tensor> target_tensors = {output_tensor};
+  std::vector<paddle::Tensor> target_tensors = {output_tensor};
   Backward(target_tensors, {});
 
   eager_test::CompareGradTensorWithValue<float>(X, 1.0);

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

@@ -83,17 +83,16 @@ TEST(NanInfUtils, Functions) {
   auto six_tensors =
       std::make_tuple(tensor, tensor1, tensor2, tensor3, tensor4, tensor5);
   CHECK_NAN_INF(six_tensors);
-  std::vector<paddle::experimental::Tensor> tensor_vec;
+  std::vector<paddle::Tensor> tensor_vec;
   tensor_vec.emplace_back(tensor);
   tensor_vec.emplace_back(tensor1);
   CHECK_NAN_INF(tensor_vec);
-  paddle::small_vector<std::vector<paddle::experimental::Tensor>,
-                       egr::kSlotSmallVectorSize>
+  paddle::small_vector<std::vector<paddle::Tensor>, egr::kSlotSmallVectorSize>
       small_vec;
   small_vec.emplace_back(tensor_vec);
   CHECK_NAN_INF(small_vec);
   // test selected_rows
-  paddle::experimental::Tensor tensor_sr;
+  paddle::Tensor tensor_sr;
   auto sr = std::make_shared<phi::SelectedRows>();
   *sr->mutable_value() =
       *(static_cast<const phi::DenseTensor*>(tensor.impl().get()));

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

@@ -33,11 +33,11 @@ TEST(TensorUtils, Test) {
   eager_test::InitEnv(paddle::platform::CPUPlace());
 
   // Prepare Inputs
-  std::vector<paddle::experimental::Tensor> target_tensors;
+  std::vector<paddle::Tensor> target_tensors;
   paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32});
 
   // Create Target Tensor
-  paddle::experimental::Tensor t =
+  paddle::Tensor t =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,
@@ -45,7 +45,7 @@ TEST(TensorUtils, Test) {
                                            5.0 /*value*/,
                                            true /*is_leaf*/);
 
-  paddle::experimental::Tensor t_grad =
+  paddle::Tensor t_grad =
       egr_utils_api::CreateTensorWithValue(ddim,
                                            paddle::platform::CPUPlace(),
                                            phi::DataType::FLOAT32,

paddle/fluid/eager/tests/test_utils.h

@@ -28,8 +28,7 @@
 namespace eager_test {
 
 template <typename T>
-bool CompareGradTensorWithValue(const paddle::experimental::Tensor& target,
-                                T value) {
+bool CompareGradTensorWithValue(const paddle::Tensor& target, T value) {
   egr::AutogradMeta* meta = egr::EagerUtils::unsafe_autograd_meta(target);
   auto grad_dense =
       std::dynamic_pointer_cast<phi::DenseTensor>(meta->Grad().impl());
@@ -68,8 +67,7 @@ bool CompareGradTensorWithValue(const paddle::experimental::Tensor& target,
 }
 
 template <typename T>
-bool CompareTensorWithValue(const paddle::experimental::Tensor& target,
-                            T value) {
+bool CompareTensorWithValue(const paddle::Tensor& target, T value) {
   // TODO(jiabin): Support Selected Rows later
   auto dense_t = std::dynamic_pointer_cast<phi::DenseTensor>(target.impl());
   T* ptr = dense_t->data<T>();

paddle/fluid/imperative/tests/test_gradient_accmulator.cc

@@ -57,13 +57,12 @@ TEST(Test__SelectedRowsMerge_Test, SelectedRowsMerge) {
     }
   }
   // new 2 phi::Tensor
-  paddle::experimental::Tensor t1(sr1);
-  paddle::experimental::Tensor t2(sr2);
+  paddle::Tensor t1(sr1);
+  paddle::Tensor t2(sr2);
 
   // call SelectedRowsMerge
   auto new_buffer =
-      paddle::imperative::SelectedRowsMerge<paddle::experimental::Tensor>(t1,
-                                                                          t2);
+      paddle::imperative::SelectedRowsMerge<paddle::Tensor>(t1, t2);
   auto* new_buffer_tensor =
       static_cast<phi::SelectedRows*>(new_buffer->impl().get());
   auto* new_buffer_data_sr1 =