From 50ad760c17664acdc351ed7a2ae8698087ea4fbe Mon Sep 17 00:00:00 2001 From: Chen Weihang Date: Tue, 7 Mar 2023 19:33:04 +0800 Subject: [PATCH] remove experimental namespace of Tensor (#51155) --- paddle/fluid/distributed/collective/reducer.h | 7 +- .../eager/accumulation/accumulation_node.cc | 40 ++- .../eager/accumulation/accumulation_node.h | 10 +- paddle/fluid/eager/amp_auto_cast.h | 12 +- paddle/fluid/eager/amp_utils.h | 6 +- .../eager_generated/backwards/scale_node.cc | 20 +- .../eager_generated/backwards/scale_node.h | 11 +- .../eager_generated/forwards/scale.cc | 12 +- .../eager_generated/forwards/scale.h | 10 +- .../manual/eager_manual/dygraph_forward_api.h | 20 +- .../eager_manual/forwards/add_n_fwd_func.cc | 6 +- .../forwards/conv2d_fwd_function.cc | 23 +- .../manual/eager_manual/nodes/add_n_node.cc | 10 +- .../manual/eager_manual/nodes/conv2d_nodes.cc | 24 +- .../api/manual/eager_manual/nodes/nodes.h | 45 ++-- .../manual/fluid_manual/dygraph_forward_api.h | 174 ++++++------- .../forwards/fused_attention_fwd_func.cc | 105 ++++---- ...as_dropout_residual_layer_norm_fwd_func.cc | 33 ++- .../forwards/fused_feedforward_fwd_func.cc | 69 +++-- .../forwards/fused_gate_attention_fwd_func.cc | 59 +++-- .../forwards/fused_gemm_epilogue_fwd_func.cc | 13 +- .../nodes/fused_attention_node.cc | 11 +- ...d_bias_dropout_residual_layer_norm_node.cc | 11 +- .../nodes/fused_feedforward_node.cc | 11 +- .../nodes/fused_gate_attention_node.cc | 11 +- .../nodes/fused_gemm_epilogue_node.cc | 11 +- .../api/manual/fluid_manual/nodes/nodes.h | 242 ++++++++---------- paddle/fluid/eager/api/utils/hook_utils.cc | 22 +- paddle/fluid/eager/api/utils/hook_utils.h | 9 +- paddle/fluid/eager/api/utils/tensor_utils.cc | 17 +- paddle/fluid/eager/api/utils/tensor_utils.h | 15 +- .../auto_code_generator/eager_generator.cc | 54 ++-- .../generator/eager_gen.py | 68 +++-- paddle/fluid/eager/autograd_meta.h | 11 +- paddle/fluid/eager/backward.cc | 38 ++- paddle/fluid/eager/backward.h | 14 +- .../custom_operator/custom_operator_node.cc | 51 ++-- .../custom_operator/custom_operator_node.h | 20 +- paddle/fluid/eager/eager_amp_auto_cast.h | 30 +-- paddle/fluid/eager/eager_layout_auto_tune.h | 18 +- paddle/fluid/eager/eager_layout_transformer.h | 90 +++---- paddle/fluid/eager/eager_tensor.h | 18 +- paddle/fluid/eager/general_grad.h | 44 ++-- paddle/fluid/eager/grad_node_info.cc | 42 ++- paddle/fluid/eager/grad_node_info.h | 31 +-- paddle/fluid/eager/grad_tensor_holder.cc | 37 ++- paddle/fluid/eager/grad_tensor_holder.h | 18 +- paddle/fluid/eager/hooks.h | 18 +- paddle/fluid/eager/nan_inf_utils.cc | 2 +- paddle/fluid/eager/nan_inf_utils.h | 4 +- paddle/fluid/eager/pylayer/py_layer_node.cc | 15 +- paddle/fluid/eager/pylayer/py_layer_node.h | 7 +- paddle/fluid/eager/tensor_wrapper.h | 14 +- .../accumulation_node_test.cc | 78 +++--- .../autograd_meta_test.cc | 4 +- .../data_structure_tests/eager_tensor_test.cc | 34 +-- .../grad_node_info_test.cc | 12 +- .../data_structure_tests/grad_node_test.h | 10 +- .../grad_tensor_holder_test.cc | 13 +- .../tensor_wrapper_test.cc | 6 +- .../performance_tests/benchmark_eager_cpu.cc | 108 ++++---- .../performance_tests/benchmark_eager_cuda.cc | 108 ++++---- .../performance_tests/benchmark_utils.cc | 40 ++- .../tests/performance_tests/benchmark_utils.h | 19 +- .../eager/tests/task_tests/backward_test.cc | 42 +-- .../cross_batch_accumulation_test.cc | 8 +- .../tests/task_tests/eager_utils_test.cc | 22 +- .../tests/task_tests/forward_autograd_test.cc | 46 ++-- .../tests/task_tests/fwd_bwd_joint_test.cc | 105 ++++---- .../eager/tests/task_tests/generated_test.cc | 18 +- .../fluid/eager/tests/task_tests/grad_test.cc | 42 +-- .../fluid/eager/tests/task_tests/hook_test.cc | 33 ++- .../task_tests/hook_test_intermidiate.cc | 31 ++- .../tests/task_tests/nan_inf_utils_test.cc | 7 +- .../tests/task_tests/tensor_utils_test.cc | 6 +- paddle/fluid/eager/tests/test_utils.h | 6 +- .../eager/to_static/run_program_op_func.h | 21 +- .../eager/to_static/run_program_op_node.h | 55 ++-- paddle/fluid/eager/utils.cc | 93 ++++--- paddle/fluid/eager/utils.h | 92 +++---- paddle/fluid/framework/custom_operator.cc | 12 +- .../fluid/imperative/gradient_accumulator.cc | 26 +- .../tests/test_gradient_accmulator.cc | 7 +- paddle/fluid/jit/engine/base_engine.h | 2 +- paddle/fluid/jit/function.h | 2 +- paddle/fluid/jit/function_utils.h | 2 +- paddle/fluid/jit/layer.h | 2 +- paddle/fluid/operators/cast_op.cc | 4 +- paddle/fluid/operators/concat_op.cc | 16 +- paddle/fluid/operators/cum_op.cc | 6 +- .../elementwise/elementwise_add_op.cc | 10 +- .../elementwise/elementwise_div_op.cc | 12 +- .../elementwise/elementwise_sub_op.cc | 10 +- paddle/fluid/operators/gather_op.cc | 10 +- .../generator/templates/operator_utils.c.j2 | 2 +- paddle/fluid/operators/matmul_v2_op.cc | 23 +- .../operators/reduce_ops/reduce_sum_op.cc | 8 +- paddle/fluid/operators/reshape_op.cc | 6 +- paddle/fluid/operators/slice_op.cc | 6 +- paddle/fluid/operators/transpose_op.cc | 7 +- .../prim/api/auto_code_generated/eager_gen.py | 2 +- .../tensor_operants_gen.py | 4 +- .../composite_backward_api.h | 5 +- .../prim/api/manual_prim/prim_manual_api.h | 2 +- .../prim/api/manual_prim/utils/eager_utils.cc | 7 +- .../api/manual_prim/utils/static_utils.cc | 8 +- paddle/fluid/prim/tests/test_eager_prim.cc | 20 +- paddle/fluid/prim/tests/test_static_prim.cc | 22 +- .../utils/static/composite_grad_desc_maker.h | 155 +++++------ paddle/fluid/pybind/distributed_py.cc | 2 +- paddle/fluid/pybind/eager.cc | 13 +- paddle/fluid/pybind/eager_functions.cc | 50 ++-- paddle/fluid/pybind/eager_math_op_patch.cc | 145 ++++++----- paddle/fluid/pybind/eager_method.cc | 84 +++--- paddle/fluid/pybind/eager_properties.cc | 3 +- paddle/fluid/pybind/eager_py_layer.cc | 22 +- paddle/fluid/pybind/eager_utils.cc | 110 ++++---- paddle/fluid/pybind/eager_utils.h | 67 +++-- paddle/fluid/pybind/imperative.cc | 2 +- paddle/fluid/pybind/inference_api.cc | 5 +- paddle/fluid/pybind/process_group_utils.h | 4 +- paddle/fluid/pybind/tensor_py.h | 13 +- paddle/phi/api/ext/op_meta_info.h | 2 +- paddle/phi/api/ext/tensor_compat.h | 1 - paddle/phi/api/include/tensor.h | 6 +- paddle/phi/api/lib/tensor.cc | 5 +- paddle/phi/api/lib/tensor_method.cc | 5 +- .../api/yaml/generator/tensor_operants_gen.py | 7 +- paddle/phi/common/int_array.h | 4 +- paddle/phi/common/scalar.h | 2 +- paddle/phi/tests/api/test_phi_tensor.cc | 7 +- .../phi/tests/api/test_strings_empty_api.cc | 4 +- .../tests/api/test_strings_lower_upper_api.cc | 4 +- paddle/phi/tests/api/test_to_api.cc | 6 +- paddle/phi/tests/common/test_int_array.cc | 8 +- paddle/phi/tests/common/test_scalar.cu | 2 +- paddle/utils/pybind.cc | 7 +- paddle/utils/pybind.h | 14 +- 138 files changed, 1738 insertions(+), 2036 deletions(-) mode change 100755 => 100644 paddle/fluid/eager/accumulation/accumulation_node.cc diff --git a/paddle/fluid/distributed/collective/reducer.h b/paddle/fluid/distributed/collective/reducer.h index 0704c5e7294..ef62ce73c52 100644 --- a/paddle/fluid/distributed/collective/reducer.h +++ b/paddle/fluid/distributed/collective/reducer.h @@ -33,10 +33,9 @@ namespace paddle { namespace distributed { -using Tensor = paddle::experimental::Tensor; -using Scalar = paddle::experimental::ScalarBase; -using IntArray = - paddle::experimental::IntArrayBase; +using Tensor = paddle::Tensor; +using Scalar = paddle::experimental::ScalarBase; +using IntArray = paddle::experimental::IntArrayBase; using Backend = paddle::experimental::Backend; std::vector> Eager_AssignGroupBySize( diff --git a/paddle/fluid/eager/accumulation/accumulation_node.cc b/paddle/fluid/eager/accumulation/accumulation_node.cc old mode 100755 new mode 100644 index f06c4b63ae2..dd0cb9b43e6 --- a/paddle/fluid/eager/accumulation/accumulation_node.cc +++ b/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(t, - tensor); + paddle::imperative::TensorAdd(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(), "tmp_accumulator"); + paddle::Tensor new_buffer(std::make_shared(), + "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(t.impl()); - paddle::experimental::Tensor t_values( - std::make_shared( - t_sparse->non_zero_elements())); + paddle::Tensor t_values(std::make_shared( + t_sparse->non_zero_elements())); auto tensor_sparse = std::dynamic_pointer_cast(tensor->impl()); - paddle::experimental::Tensor tensor_values( - std::make_shared( - tensor_sparse->non_zero_elements())); + paddle::Tensor tensor_values(std::make_shared( + tensor_sparse->non_zero_elements())); if (t.is_custom_device()) { tensor_values = add_ad_func(t_values, tensor_values); } else { - paddle::imperative::TensorAdd( - t_values, &tensor_values); + paddle::imperative::TensorAdd(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( + t, *tensor)); } } } } } -paddle::small_vector, - kSlotSmallVectorSize> +paddle::small_vector, kSlotSmallVectorSize> GradNodeAccumulation::operator()( - paddle::small_vector, + paddle::small_vector, 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, - kSlotSmallVectorSize> + paddle::small_vector, kSlotSmallVectorSize> hooked_grads = ApplyGradientHooks(grads); grad_out = hooked_grads[0][0]; } else { diff --git a/paddle/fluid/eager/accumulation/accumulation_node.h b/paddle/fluid/eager/accumulation/accumulation_node.h index dcac3c5a0e1..cd6202b5fd7 100644 --- a/paddle/fluid/eager/accumulation/accumulation_node.h +++ b/paddle/fluid/eager/accumulation/accumulation_node.h @@ -37,9 +37,9 @@ class GradNodeAccumulation : public GradNodeBase { } // Functor: perform backward computations - virtual paddle::small_vector, + virtual paddle::small_vector, kSlotSmallVectorSize> - operator()(paddle::small_vector, + operator()(paddle::small_vector, 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 weak_grad_; + std::weak_ptr weak_grad_; std::vector> reduce_hooks_; - std::function - retain_grad_hook_; + std::function retain_grad_hook_; }; } // namespace egr diff --git a/paddle/fluid/eager/amp_auto_cast.h b/paddle/fluid/eager/amp_auto_cast.h index 0bf5875823b..14093af414f 100644 --- a/paddle/fluid/eager/amp_auto_cast.h +++ b/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 AmpAutoCasts( +inline std::vector AmpAutoCasts( const std::string& inputs_name, - const std::vector& inputs, + const std::vector& 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 inputs_casted; + std::vector inputs_casted; for (auto& input : inputs) { if (NeedCast(input, dst_dtype)) { paddle::framework::AttributeMap cast_attrs = { @@ -65,9 +65,9 @@ inline std::vector 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:" diff --git a/paddle/fluid/eager/amp_utils.h b/paddle/fluid/eager/amp_utils.h index 7b8071ee601..1579b884a20 100644 --- a/paddle/fluid/eager/amp_utils.h +++ b/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, + const paddle::small_vector, 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, + const paddle::small_vector, 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, + const paddle::small_vector, kSlotSmallVectorSize>& amp_tensors_vector) { auto amp_dtype = egr::Controller::Instance().GetCurrentTracer()->GetAmpDtype(); diff --git a/paddle/fluid/eager/api/generated/eager_generated/backwards/scale_node.cc b/paddle/fluid/eager/api/generated/eager_generated/backwards/scale_node.cc index 002b8330763..7567236c4ff 100644 --- a/paddle/fluid/eager/api/generated/eager_generated/backwards/scale_node.cc +++ b/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& tensors) { + const std::vector& tensors) { // Does nothing for scale } void GradNodeScale::SetAttributes_scale(float scale) { scale_ = scale; } -paddle::small_vector, - kSlotSmallVectorSize> +paddle::small_vector, kSlotSmallVectorSize> GradNodeScale::operator()( - paddle::small_vector, + paddle::small_vector, 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, - kSlotSmallVectorSize> - outs; + paddle::small_vector, 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> to apply all hooks? - paddle::small_vector, - kSlotSmallVectorSize> + paddle::small_vector, kSlotSmallVectorSize> hooked_grads = ApplyGradientHooks(grads); ScaleAPI(/* slot by slot set */ hooked_grads[0][0], scale_, diff --git a/paddle/fluid/eager/api/generated/eager_generated/backwards/scale_node.h b/paddle/fluid/eager/api/generated/eager_generated/backwards/scale_node.h index 83f656b5711..68bb2089b19 100644 --- a/paddle/fluid/eager/api/generated/eager_generated/backwards/scale_node.h +++ b/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, + virtual paddle::small_vector, kSlotSmallVectorSize> - operator()(paddle::small_vector, + operator()(paddle::small_vector, 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& tensors); + void SetTensorWrappers_X(const std::vector& tensors); void SetAttributes_scale(float scale); std::string name() override { return "scale node"; } diff --git a/paddle/fluid/eager/api/generated/eager_generated/forwards/scale.cc b/paddle/fluid/eager/api/generated/eager_generated/forwards/scale.cc index 532ea27b46c..7db484207a2 100644 --- a/paddle/fluid/eager/api/generated/eager_generated/forwards/scale.cc +++ b/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 diff --git a/paddle/fluid/eager/api/generated/eager_generated/forwards/scale.h b/paddle/fluid/eager/api/generated/eager_generated/forwards/scale.h index 7cbe83f2cf4..cb6929f99ae 100644 --- a/paddle/fluid/eager/api/generated/eager_generated/forwards/scale.h +++ b/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 diff --git a/paddle/fluid/eager/api/manual/eager_manual/dygraph_forward_api.h b/paddle/fluid/eager/api/manual/eager_manual/dygraph_forward_api.h index 22a4b03312c..215d5ce5ff4 100644 --- a/paddle/fluid/eager/api/manual/eager_manual/dygraph_forward_api.h +++ b/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& x); +paddle::Tensor add_n_ad_func(const std::vector& x); -paddle::experimental::Tensor conv2d_ad_func( - const paddle::experimental::Tensor& input, - const paddle::experimental::Tensor& filter, - std::vector strides, - std::vector paddings, - std::string padding_algorithm, - std::vector dilations, - int groups, - std::string data_format); +paddle::Tensor conv2d_ad_func(const paddle::Tensor& input, + const paddle::Tensor& filter, + std::vector strides, + std::vector paddings, + std::string padding_algorithm, + std::vector dilations, + int groups, + std::string data_format); diff --git a/paddle/fluid/eager/api/manual/eager_manual/forwards/add_n_fwd_func.cc b/paddle/fluid/eager/api/manual/eager_manual/forwards/add_n_fwd_func.cc index a6f1b99e1f0..ea7dcd8a5f0 100644 --- a/paddle/fluid/eager/api/manual/eager_manual/forwards/add_n_fwd_func.cc +++ b/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& x) { +paddle::Tensor add_n_ad_func(const std::vector& 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, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> amp_tensors_vector = {x}; auto amp_dst_dtype = egr::GetAmpDestDtype(op_name, amp_tensors_vector); diff --git a/paddle/fluid/eager/api/manual/eager_manual/forwards/conv2d_fwd_function.cc b/paddle/fluid/eager/api/manual/eager_manual/forwards/conv2d_fwd_function.cc index df5feab911f..84938933f9e 100644 --- a/paddle/fluid/eager/api/manual/eager_manual/forwards/conv2d_fwd_function.cc +++ b/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 strides, - std::vector paddings, - std::string padding_algorithm, - std::vector dilations, - int groups, - std::string data_format) { +paddle::Tensor conv2d_ad_func(const paddle::Tensor& input, + const paddle::Tensor& filter, + std::vector strides, + std::vector paddings, + std::string padding_algorithm, + std::vector 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, - egr::kSlotSmallVectorSize> + paddle::small_vector, 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, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> tensors_vector = {{input}, {filter}}; auto op_name = phi::TransToFluidOpName("conv2d"); diff --git a/paddle/fluid/eager/api/manual/eager_manual/nodes/add_n_node.cc b/paddle/fluid/eager/api/manual/eager_manual/nodes/add_n_node.cc index 6f7a34094b1..896660c45f6 100644 --- a/paddle/fluid/eager/api/manual/eager_manual/nodes/add_n_node.cc +++ b/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, - egr::kSlotSmallVectorSize> +paddle::small_vector, egr::kSlotSmallVectorSize> AddNGradNodeFinal::operator()( - paddle::small_vector, + paddle::small_vector, 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, - egr::kSlotSmallVectorSize> + paddle::small_vector, 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 api_output_0; + std::vector 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()) { diff --git a/paddle/fluid/eager/api/manual/eager_manual/nodes/conv2d_nodes.cc b/paddle/fluid/eager/api/manual/eager_manual/nodes/conv2d_nodes.cc index 8ba19d99cf4..ce06b027287 100644 --- a/paddle/fluid/eager/api/manual/eager_manual/nodes/conv2d_nodes.cc +++ b/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, - egr::kSlotSmallVectorSize> +paddle::small_vector, egr::kSlotSmallVectorSize> Conv2dGradNodeFinal::operator()( - paddle::small_vector, + paddle::small_vector, 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, - egr::kSlotSmallVectorSize> + paddle::small_vector, 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, - egr::kSlotSmallVectorSize> +paddle::small_vector, egr::kSlotSmallVectorSize> Conv2dDoubleGradNodeFinal::operator()( - paddle::small_vector, + paddle::small_vector, 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 grad_input_grad_optional; + paddle::optional grad_input_grad_optional; if (grad_input_grad.initialized()) grad_input_grad_optional = - paddle::make_optional(grad_input_grad); + paddle::make_optional(grad_input_grad); auto& grad_filter_grad = hooked_grads[1][0]; - paddle::optional grad_filter_grad_optional; + paddle::optional grad_filter_grad_optional; if (grad_filter_grad.initialized()) grad_filter_grad_optional = - paddle::make_optional(grad_filter_grad); + paddle::make_optional(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, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> returns(3); for (int i = 0; i < 3; ++i) { out_metas[i].size() == 0 ? returns[i].resize(1) diff --git a/paddle/fluid/eager/api/manual/eager_manual/nodes/nodes.h b/paddle/fluid/eager/api/manual/eager_manual/nodes/nodes.h index 6fb58370384..512558014e7 100644 --- a/paddle/fluid/eager/api/manual/eager_manual/nodes/nodes.h +++ b/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, + virtual paddle::small_vector, egr::kSlotSmallVectorSize> - operator()( - paddle::small_vector, // NOLINT - egr::kSlotSmallVectorSize>& grads, // NOLINT - bool create_graph = false, // NOLINT - bool is_new_grad = false) override; // NOLINT + operator()(paddle::small_vector, // 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, + virtual paddle::small_vector, egr::kSlotSmallVectorSize> - operator()( - paddle::small_vector, // NOLINT - egr::kSlotSmallVectorSize>& grads, // NOLINT - bool create_graph = false, // NOLINT - bool is_new_grad = false) override; // NOLINT + operator()(paddle::small_vector, // 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, + virtual paddle::small_vector, egr::kSlotSmallVectorSize> - operator()( - paddle::small_vector, // NOLINT - egr::kSlotSmallVectorSize>& grads, // NOLINT - bool create_graph = false, - bool is_new_grad = false) override; + operator()(paddle::small_vector, // 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& x) { + void SetTensorWrapperx(const std::vector& x) { for (const auto& eager_tensor : x) { x_.emplace_back(egr::TensorWrapper(eager_tensor, true)); } diff --git a/paddle/fluid/eager/api/manual/fluid_manual/dygraph_forward_api.h b/paddle/fluid/eager/api/manual/fluid_manual/dygraph_forward_api.h index 4fa64f35c72..7fda5aa69b7 100644 --- a/paddle/fluid/eager/api/manual/fluid_manual/dygraph_forward_api.h +++ b/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 +std::tuple 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 +std::tuple 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 +std::tuple 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 +std::tuple 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); diff --git a/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_attention_fwd_func.cc b/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_attention_fwd_func.cc index db1d6c1d409..77ecc8a30e1 100644 --- a/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_attention_fwd_func.cc +++ b/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 +std::tuple 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, - egr::kSlotSmallVectorSize> + paddle::small_vector, 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); { diff --git a/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_bias_dropout_residual_layer_norm_fwd_func.cc b/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_bias_dropout_residual_layer_norm_fwd_func.cc index 2544ad7b6e2..4b57d2e3c5b 100644 --- a/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_bias_dropout_residual_layer_norm_fwd_func.cc +++ b/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 +std::tuple 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, - egr::kSlotSmallVectorSize> + paddle::small_vector, 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); { diff --git a/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_feedforward_fwd_func.cc b/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_feedforward_fwd_func.cc index dce620fd32a..9f13579c5aa 100644 --- a/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_feedforward_fwd_func.cc +++ b/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 +std::tuple 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, - egr::kSlotSmallVectorSize> + paddle::small_vector, 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); { diff --git a/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_gate_attention_fwd_func.cc b/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_gate_attention_fwd_func.cc index 1ad201a8f81..fd3d32401d9 100644 --- a/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_gate_attention_fwd_func.cc +++ b/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 +std::tuple 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, - egr::kSlotSmallVectorSize> + paddle::small_vector, 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); { diff --git a/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_gemm_epilogue_fwd_func.cc b/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_gemm_epilogue_fwd_func.cc index 72dccb3bb0d..2eb73276011 100644 --- a/paddle/fluid/eager/api/manual/fluid_manual/forwards/fused_gemm_epilogue_fwd_func.cc +++ b/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, - egr::kSlotSmallVectorSize> + paddle::small_vector, 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); { diff --git a/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_attention_node.cc b/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_attention_node.cc index 11445880fe8..26649449263 100644 --- a/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_attention_node.cc +++ b/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, - egr::kSlotSmallVectorSize> +paddle::small_vector, egr::kSlotSmallVectorSize> fused_attentionGradNodeCompat::operator()( - paddle::small_vector, + paddle::small_vector, 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, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> outputs(23); - paddle::small_vector, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> hooked_grads0 = fused_attentionGradNodeCompat::ApplyGradientHooks(grads); bool pre_layer_norm = false; diff --git a/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_bias_dropout_residual_layer_norm_node.cc b/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_bias_dropout_residual_layer_norm_node.cc index 2c7800fc1c2..5886325c8eb 100644 --- a/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_bias_dropout_residual_layer_norm_node.cc +++ b/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, - egr::kSlotSmallVectorSize> +paddle::small_vector, egr::kSlotSmallVectorSize> fused_bias_dropout_residual_layer_normGradNodeCompat::operator()( - paddle::small_vector, + paddle::small_vector, egr::kSlotSmallVectorSize>& grads, bool create_graph, bool is_new_grad) { const auto& out_metas = OutputMeta(); - paddle::small_vector, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> outputs(5); VLOG(3) << "Running Eager Backward Node: " "fused_bias_dropout_residual_layer_normGradNodeCompat"; - paddle::small_vector, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> hooked_grads0 = fused_bias_dropout_residual_layer_normGradNodeCompat:: ApplyGradientHooks(grads); std::map>> ins0 = diff --git a/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_feedforward_node.cc b/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_feedforward_node.cc index b5907f444c8..69ee238acd0 100644 --- a/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_feedforward_node.cc +++ b/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, - egr::kSlotSmallVectorSize> +paddle::small_vector, egr::kSlotSmallVectorSize> fused_feedforwardGradNodeCompat::operator()( - paddle::small_vector, + paddle::small_vector, 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, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> outputs(11); - paddle::small_vector, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> hooked_grads0 = fused_feedforwardGradNodeCompat::ApplyGradientHooks(grads); diff --git a/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_gate_attention_node.cc b/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_gate_attention_node.cc index f9911798b1a..8c427eba8cd 100644 --- a/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_gate_attention_node.cc +++ b/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, - egr::kSlotSmallVectorSize> +paddle::small_vector, egr::kSlotSmallVectorSize> fused_gate_attentionGradNodeCompat::operator()( - paddle::small_vector, + paddle::small_vector, 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, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> outputs(12); - paddle::small_vector, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> hooked_grads0 = fused_gate_attentionGradNodeCompat::ApplyGradientHooks(grads); diff --git a/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_gemm_epilogue_node.cc b/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_gemm_epilogue_node.cc index 68c183120d4..8031ff9d14d 100644 --- a/paddle/fluid/eager/api/manual/fluid_manual/nodes/fused_gemm_epilogue_node.cc +++ b/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, - egr::kSlotSmallVectorSize> +paddle::small_vector, egr::kSlotSmallVectorSize> fused_gemm_epilogueGradNodeCompat::operator()( - paddle::small_vector, + paddle::small_vector, egr::kSlotSmallVectorSize>& grads, bool create_graph, bool is_new_grad) { const auto& out_metas = OutputMeta(); - paddle::small_vector, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> outputs(3); VLOG(3) << "Running Eager Backward Node: fused_gemm_epilogueGradNodeCompat"; - paddle::small_vector, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> hooked_grads0 = fused_gemm_epilogueGradNodeCompat::ApplyGradientHooks(grads); std::map>> ins0 = diff --git a/paddle/fluid/eager/api/manual/fluid_manual/nodes/nodes.h b/paddle/fluid/eager/api/manual/fluid_manual/nodes/nodes.h index 54fa96e24fa..b0576672ae1 100644 --- a/paddle/fluid/eager/api/manual/fluid_manual/nodes/nodes.h +++ b/paddle/fluid/eager/api/manual/fluid_manual/nodes/nodes.h @@ -48,13 +48,12 @@ class fused_gate_attentionGradNodeCompat : public egr::GradNodeBase { VLOG(6) << " Destruct fused_gate_attentionGradNodeCompat "; } - virtual paddle::small_vector, + virtual paddle::small_vector, egr::kSlotSmallVectorSize> - operator()( - paddle::small_vector, // NOLINT - egr::kSlotSmallVectorSize>& grads, // NOLINT - bool create_graph = false, - bool is_new_grad = false) override; + operator()(paddle::small_vector, // NOLINT + egr::kSlotSmallVectorSize>& grads, // NOLINT + bool create_graph = false, + bool is_new_grad = false) override; void ClearTensorWrappers() override { FMHAOut_.clear(); @@ -89,71 +88,60 @@ class fused_gate_attentionGradNodeCompat : public egr::GradNodeBase { } // SetX, SetY, ... - void SetTensorWrapperFMHAOut(const paddle::experimental::Tensor& FMHAOut) { + void SetTensorWrapperFMHAOut(const paddle::Tensor& FMHAOut) { FMHAOut_ = egr::TensorWrapper(FMHAOut, false); } - void SetTensorWrapperGateBias(const paddle::experimental::Tensor& GateBias) { + void SetTensorWrapperGateBias(const paddle::Tensor& GateBias) { GateBias_ = egr::TensorWrapper(GateBias, false); } - void SetTensorWrapperGateOut(const paddle::experimental::Tensor& GateOut) { + void SetTensorWrapperGateOut(const paddle::Tensor& GateOut) { GateOut_ = egr::TensorWrapper(GateOut, false); } - void SetTensorWrapperGateWeight( - const paddle::experimental::Tensor& GateWeight) { + void SetTensorWrapperGateWeight(const paddle::Tensor& GateWeight) { GateWeight_ = egr::TensorWrapper(GateWeight, false); } - void SetTensorWrapperNonbatchedBias( - const paddle::experimental::Tensor& NonbatchedBias) { + void SetTensorWrapperNonbatchedBias(const paddle::Tensor& NonbatchedBias) { NonbatchedBias_ = egr::TensorWrapper(NonbatchedBias, false); } - void SetTensorWrapperOutLinearBias( - const paddle::experimental::Tensor& OutLinearBias) { + void SetTensorWrapperOutLinearBias(const paddle::Tensor& OutLinearBias) { OutLinearBias_ = egr::TensorWrapper(OutLinearBias, false); } - void SetTensorWrapperOutLinearWeight( - const paddle::experimental::Tensor& OutLinearWeight) { + void SetTensorWrapperOutLinearWeight(const paddle::Tensor& OutLinearWeight) { OutLinearWeight_ = egr::TensorWrapper(OutLinearWeight, false); } - void SetTensorWrapperQKVTransposeOut( - const paddle::experimental::Tensor& QKVTransposeOut) { + void SetTensorWrapperQKVTransposeOut(const paddle::Tensor& QKVTransposeOut) { QKVTransposeOut_ = egr::TensorWrapper(QKVTransposeOut, false); } - void SetTensorWrapperQKVWeight( - const paddle::experimental::Tensor& QKVWeight) { + void SetTensorWrapperQKVWeight(const paddle::Tensor& QKVWeight) { QKVWeight_ = egr::TensorWrapper(QKVWeight, false); } - void SetTensorWrapperQuery(const paddle::experimental::Tensor& Query) { + void SetTensorWrapperQuery(const paddle::Tensor& Query) { Query_ = egr::TensorWrapper(Query, false); } - void SetTensorWrapperSoftmaxOut( - const paddle::experimental::Tensor& SoftmaxOut) { + void SetTensorWrapperSoftmaxOut(const paddle::Tensor& SoftmaxOut) { SoftmaxOut_ = egr::TensorWrapper(SoftmaxOut, false); } - void SetTensorWrapperKey(const paddle::experimental::Tensor& Key) { + void SetTensorWrapperKey(const paddle::Tensor& Key) { Key_ = egr::TensorWrapper(Key, false); } - void SetTensorWrapperQueryWeight( - const paddle::experimental::Tensor& QueryWeight) { + void SetTensorWrapperQueryWeight(const paddle::Tensor& QueryWeight) { QueryWeight_ = egr::TensorWrapper(QueryWeight, false); } - void SetTensorWrapperKeyWeight( - const paddle::experimental::Tensor& KeyWeight) { + void SetTensorWrapperKeyWeight(const paddle::Tensor& KeyWeight) { KeyWeight_ = egr::TensorWrapper(KeyWeight, false); } - void SetTensorWrapperValueWeight( - const paddle::experimental::Tensor& ValueWeight) { + void SetTensorWrapperValueWeight(const paddle::Tensor& ValueWeight) { ValueWeight_ = egr::TensorWrapper(ValueWeight, false); } void SetTensorWrapperQueryTransposeOut( - const paddle::experimental::Tensor& QueryTransposeOut) { + const paddle::Tensor& QueryTransposeOut) { QueryTransposeOut_ = egr::TensorWrapper(QueryTransposeOut, false); } - void SetTensorWrapperKeyTransposeOut( - const paddle::experimental::Tensor& KeyTransposeOut) { + void SetTensorWrapperKeyTransposeOut(const paddle::Tensor& KeyTransposeOut) { KeyTransposeOut_ = egr::TensorWrapper(KeyTransposeOut, false); } void SetTensorWrapperValueTransposeOut( - const paddle::experimental::Tensor& ValueTransposeOut) { + const paddle::Tensor& ValueTransposeOut) { ValueTransposeOut_ = egr::TensorWrapper(ValueTransposeOut, false); } @@ -206,13 +194,12 @@ class fused_feedforwardGradNodeCompat : public egr::GradNodeBase { VLOG(6) << " Destruct fused_feedforwardGradNodeCompat "; } - virtual paddle::small_vector, + virtual paddle::small_vector, egr::kSlotSmallVectorSize> - operator()( - paddle::small_vector, // NOLINT - egr::kSlotSmallVectorSize>& grads, // NOLINT - bool create_graph = false, - bool is_new_grad = false) override; + operator()(paddle::small_vector, // NOLINT + egr::kSlotSmallVectorSize>& grads, // NOLINT + bool create_graph = false, + bool is_new_grad = false) override; void ClearTensorWrappers() override { Dropout1Mask_.clear(); @@ -243,74 +230,63 @@ class fused_feedforwardGradNodeCompat : public egr::GradNodeBase { } // SetX, SetY, ... - void SetTensorWrapperDropout1Mask( - const paddle::experimental::Tensor& Dropout1Mask) { + void SetTensorWrapperDropout1Mask(const paddle::Tensor& Dropout1Mask) { Dropout1Mask_ = egr::TensorWrapper(Dropout1Mask, false); } - void SetTensorWrapperDropout1Out( - const paddle::experimental::Tensor& Dropout1Out) { + void SetTensorWrapperDropout1Out(const paddle::Tensor& Dropout1Out) { Dropout1Out_ = egr::TensorWrapper(Dropout1Out, false); } - void SetTensorWrapperDropout2Mask( - const paddle::experimental::Tensor& Dropout2Mask) { + void SetTensorWrapperDropout2Mask(const paddle::Tensor& Dropout2Mask) { Dropout2Mask_ = egr::TensorWrapper(Dropout2Mask, false); } - void SetTensorWrapperDropout2Out( - const paddle::experimental::Tensor& Dropout2Out) { + void SetTensorWrapperDropout2Out(const paddle::Tensor& Dropout2Out) { auto pre_layer_norm = GetAttrWithDefault( attr_map_, default_attr_map_, "pre_layer_norm"); Dropout2Out_ = egr::TensorWrapper(Dropout2Out, pre_layer_norm); } - void SetTensorWrapperLinear1Bias( - const paddle::experimental::Tensor& Linear1Bias) { + void SetTensorWrapperLinear1Bias(const paddle::Tensor& Linear1Bias) { Linear1Bias_ = egr::TensorWrapper(Linear1Bias, false); } - void SetTensorWrapperLinear1Out( - const paddle::experimental::Tensor& Linear1Out) { + void SetTensorWrapperLinear1Out(const paddle::Tensor& Linear1Out) { Linear1Out_ = egr::TensorWrapper(Linear1Out, false); } - void SetTensorWrapperLinear1Weight( - const paddle::experimental::Tensor& Linear1Weight) { + void SetTensorWrapperLinear1Weight(const paddle::Tensor& Linear1Weight) { Linear1Weight_ = egr::TensorWrapper(Linear1Weight, false); } - void SetTensorWrapperLinear2Bias( - const paddle::experimental::Tensor& Linear2Bias) { + void SetTensorWrapperLinear2Bias(const paddle::Tensor& Linear2Bias) { Linear2Bias_ = egr::TensorWrapper(Linear2Bias, false); } - void SetTensorWrapperLinear2Weight( - const paddle::experimental::Tensor& Linear2Weight) { + void SetTensorWrapperLinear2Weight(const paddle::Tensor& Linear2Weight) { Linear2Weight_ = egr::TensorWrapper(Linear2Weight, false); } - void SetTensorWrapperLn2Bias(const paddle::experimental::Tensor& Ln2Bias) { + void SetTensorWrapperLn2Bias(const paddle::Tensor& Ln2Bias) { Ln2Bias_ = egr::TensorWrapper(Ln2Bias, false); } - void SetTensorWrapperLn2Mean(const paddle::experimental::Tensor& Ln2Mean) { + void SetTensorWrapperLn2Mean(const paddle::Tensor& Ln2Mean) { Ln2Mean_ = egr::TensorWrapper(Ln2Mean, false); } - void SetTensorWrapperLn2Scale(const paddle::experimental::Tensor& Ln2Scale) { + void SetTensorWrapperLn2Scale(const paddle::Tensor& Ln2Scale) { Ln2Scale_ = egr::TensorWrapper(Ln2Scale, false); } - void SetTensorWrapperLn2Variance( - const paddle::experimental::Tensor& Ln2Variance) { + void SetTensorWrapperLn2Variance(const paddle::Tensor& Ln2Variance) { Ln2Variance_ = egr::TensorWrapper(Ln2Variance, false); } - void SetTensorWrapperX(const paddle::experimental::Tensor& X) { + void SetTensorWrapperX(const paddle::Tensor& X) { X_ = egr::TensorWrapper(X, false); } - void SetTensorWrapperLn1Scale(const paddle::experimental::Tensor& Ln1Scale) { + void SetTensorWrapperLn1Scale(const paddle::Tensor& Ln1Scale) { Ln1Scale_ = egr::TensorWrapper(Ln1Scale, false); } - void SetTensorWrapperLn1Bias(const paddle::experimental::Tensor& Ln1Bias) { + void SetTensorWrapperLn1Bias(const paddle::Tensor& Ln1Bias) { Ln1Bias_ = egr::TensorWrapper(Ln1Bias, false); } - void SetTensorWrapperLn1Out(const paddle::experimental::Tensor& Ln1Out) { + void SetTensorWrapperLn1Out(const paddle::Tensor& Ln1Out) { Ln1Out_ = egr::TensorWrapper(Ln1Out, false); } - void SetTensorWrapperLn1Mean(const paddle::experimental::Tensor& Ln1Mean) { + void SetTensorWrapperLn1Mean(const paddle::Tensor& Ln1Mean) { Ln1Mean_ = egr::TensorWrapper(Ln1Mean, false); } - void SetTensorWrapperLn1Variance( - const paddle::experimental::Tensor& Ln1Variance) { + void SetTensorWrapperLn1Variance(const paddle::Tensor& Ln1Variance) { Ln1Variance_ = egr::TensorWrapper(Ln1Variance, false); } // SetAttrMap @@ -362,13 +338,12 @@ class fused_attentionGradNodeCompat : public egr::GradNodeBase { VLOG(6) << " Destruct fused_attentionGradNodeCompat "; } - virtual paddle::small_vector, + virtual paddle::small_vector, egr::kSlotSmallVectorSize> - operator()( - paddle::small_vector, // NOLINT - egr::kSlotSmallVectorSize>& grads, // NOLINT - bool create_graph = false, - bool is_new_grad = false) override; + operator()(paddle::small_vector, // NOLINT + egr::kSlotSmallVectorSize>& grads, // NOLINT + bool create_graph = false, + bool is_new_grad = false) override; void ClearTensorWrappers() override { AttnDropoutMaskOut_.clear(); @@ -409,100 +384,89 @@ class fused_attentionGradNodeCompat : public egr::GradNodeBase { // SetX, SetY, ... void SetTensorWrapperAttnDropoutMaskOut( - const paddle::experimental::Tensor& AttnDropoutMaskOut) { + const paddle::Tensor& AttnDropoutMaskOut) { AttnDropoutMaskOut_ = egr::TensorWrapper(AttnDropoutMaskOut, false); } - void SetTensorWrapperAttnDropoutOut( - const paddle::experimental::Tensor& AttnDropoutOut) { + void SetTensorWrapperAttnDropoutOut(const paddle::Tensor& AttnDropoutOut) { AttnDropoutOut_ = egr::TensorWrapper(AttnDropoutOut, false); } void SetTensorWrapperBiasDropoutResidualOut( - const paddle::experimental::Tensor& BiasDropoutResidualOut) { + const paddle::Tensor& BiasDropoutResidualOut) { BiasDropoutResidualOut_ = egr::TensorWrapper(BiasDropoutResidualOut, false); } - void SetTensorWrapperDropoutMaskOut( - const paddle::experimental::Tensor& DropoutMaskOut) { + void SetTensorWrapperDropoutMaskOut(const paddle::Tensor& DropoutMaskOut) { DropoutMaskOut_ = egr::TensorWrapper(DropoutMaskOut, false); } - void SetTensorWrapperFMHAOut(const paddle::experimental::Tensor& FMHAOut) { + void SetTensorWrapperFMHAOut(const paddle::Tensor& FMHAOut) { FMHAOut_ = egr::TensorWrapper(FMHAOut, false); } - void SetTensorWrapperLn2Bias(const paddle::experimental::Tensor& Ln2Bias) { + void SetTensorWrapperLn2Bias(const paddle::Tensor& Ln2Bias) { Ln2Bias_ = egr::TensorWrapper(Ln2Bias, false); } - void SetTensorWrapperLn2Mean(const paddle::experimental::Tensor& Ln2Mean) { + void SetTensorWrapperLn2Mean(const paddle::Tensor& Ln2Mean) { Ln2Mean_ = egr::TensorWrapper(Ln2Mean, false); } - void SetTensorWrapperLn2Scale(const paddle::experimental::Tensor& Ln2Scale) { + void SetTensorWrapperLn2Scale(const paddle::Tensor& Ln2Scale) { Ln2Scale_ = egr::TensorWrapper(Ln2Scale, false); } - void SetTensorWrapperLn2Variance( - const paddle::experimental::Tensor& Ln2Variance) { + void SetTensorWrapperLn2Variance(const paddle::Tensor& Ln2Variance) { Ln2Variance_ = egr::TensorWrapper(Ln2Variance, false); } - void SetTensorWrapperOutLinearBias( - const paddle::experimental::Tensor& OutLinearBias) { + void SetTensorWrapperOutLinearBias(const paddle::Tensor& OutLinearBias) { OutLinearBias_ = egr::TensorWrapper(OutLinearBias, false); } - void SetTensorWrapperOutLinearOut( - const paddle::experimental::Tensor& OutLinearOut) { + void SetTensorWrapperOutLinearOut(const paddle::Tensor& OutLinearOut) { OutLinearOut_ = egr::TensorWrapper(OutLinearOut, true); } - void SetTensorWrapperOutLinearW( - const paddle::experimental::Tensor& OutLinearW) { + void SetTensorWrapperOutLinearW(const paddle::Tensor& OutLinearW) { OutLinearW_ = egr::TensorWrapper(OutLinearW, false); } - void SetTensorWrapperQKOut(const paddle::experimental::Tensor& QKOut) { + void SetTensorWrapperQKOut(const paddle::Tensor& QKOut) { QKOut_ = egr::TensorWrapper(QKOut, true); } - void SetTensorWrapperQKTVOut(const paddle::experimental::Tensor& QKTVOut) { + void SetTensorWrapperQKTVOut(const paddle::Tensor& QKTVOut) { QKTVOut_ = egr::TensorWrapper(QKTVOut, true); } - void SetTensorWrapperQKVBias(const paddle::experimental::Tensor& QKVBias) { + void SetTensorWrapperQKVBias(const paddle::Tensor& QKVBias) { QKVBias_ = egr::TensorWrapper(QKVBias, false); } - void SetTensorWrapperQKVBiasOut( - const paddle::experimental::Tensor& QKVBiasOut) { + void SetTensorWrapperQKVBiasOut(const paddle::Tensor& QKVBiasOut) { QKVBiasOut_ = egr::TensorWrapper(QKVBiasOut, true); } - void SetTensorWrapperQKVOut(const paddle::experimental::Tensor& QKVOut) { + void SetTensorWrapperQKVOut(const paddle::Tensor& QKVOut) { QKVOut_ = egr::TensorWrapper(QKVOut, true); } - void SetTensorWrapperQKVW(const paddle::experimental::Tensor& QKVW) { + void SetTensorWrapperQKVW(const paddle::Tensor& QKVW) { QKVW_ = egr::TensorWrapper(QKVW, false); } - void SetTensorWrapperSoftmaxOut( - const paddle::experimental::Tensor& SoftmaxOut) { + void SetTensorWrapperSoftmaxOut(const paddle::Tensor& SoftmaxOut) { SoftmaxOut_ = egr::TensorWrapper(SoftmaxOut, false); } - void SetTensorWrapperSrcMask(const paddle::experimental::Tensor& SrcMask) { + void SetTensorWrapperSrcMask(const paddle::Tensor& SrcMask) { SrcMask_ = egr::TensorWrapper(SrcMask, true); } - void SetTensorWrapperSrcMaskOut( - const paddle::experimental::Tensor& SrcMaskOut) { + void SetTensorWrapperSrcMaskOut(const paddle::Tensor& SrcMaskOut) { SrcMaskOut_ = egr::TensorWrapper(SrcMaskOut, false); } - void SetTensorWrapperTransposeOut2( - const paddle::experimental::Tensor& TransposeOut2) { + void SetTensorWrapperTransposeOut2(const paddle::Tensor& TransposeOut2) { TransposeOut2_ = egr::TensorWrapper(TransposeOut2, false); } - void SetTensorWrapperX(const paddle::experimental::Tensor& X) { + void SetTensorWrapperX(const paddle::Tensor& X) { X_ = egr::TensorWrapper(X, false); } - void SetTensorWrapperLnScale(const paddle::experimental::Tensor& LnScale) { + void SetTensorWrapperLnScale(const paddle::Tensor& LnScale) { LnScale_ = egr::TensorWrapper(LnScale, false); } - void SetTensorWrapperLnBias(const paddle::experimental::Tensor& LnBias) { + void SetTensorWrapperLnBias(const paddle::Tensor& LnBias) { LnBias_ = egr::TensorWrapper(LnBias, false); } - void SetTensorWrapperLnOut(const paddle::experimental::Tensor& LnOut) { + void SetTensorWrapperLnOut(const paddle::Tensor& LnOut) { LnOut_ = egr::TensorWrapper(LnOut, false); } - void SetTensorWrapperLnMean(const paddle::experimental::Tensor& LnMean) { + void SetTensorWrapperLnMean(const paddle::Tensor& LnMean) { LnMean_ = egr::TensorWrapper(LnMean, false); } - void SetTensorWrapperLnVariance( - const paddle::experimental::Tensor& LnVariance) { + void SetTensorWrapperLnVariance(const paddle::Tensor& LnVariance) { LnVariance_ = egr::TensorWrapper(LnVariance, false); } @@ -565,13 +529,12 @@ class fused_gemm_epilogueGradNodeCompat : public egr::GradNodeBase { VLOG(6) << " Destruct fused_gemm_epilogueGradNodeCompat "; } - virtual paddle::small_vector, + virtual paddle::small_vector, egr::kSlotSmallVectorSize> - operator()( - paddle::small_vector, // NOLINT - egr::kSlotSmallVectorSize>& grads, // NOLINT - bool create_graph = false, - bool is_new_grad = false) override; + operator()(paddle::small_vector, // NOLINT + egr::kSlotSmallVectorSize>& grads, // NOLINT + bool create_graph = false, + bool is_new_grad = false) override; void ClearTensorWrappers() override { X_.clear(); @@ -590,10 +553,10 @@ class fused_gemm_epilogueGradNodeCompat : public egr::GradNodeBase { } // SetX, SetY, ... - void SetTensorWrapperX(const paddle::experimental::Tensor& X) { + void SetTensorWrapperX(const paddle::Tensor& X) { X_ = egr::TensorWrapper(X, false); } - void SetTensorWrapperY(const paddle::experimental::Tensor& Y) { + void SetTensorWrapperY(const paddle::Tensor& Y) { Y_ = egr::TensorWrapper(Y, false); } @@ -633,13 +596,12 @@ class fused_bias_dropout_residual_layer_normGradNodeCompat << " Destruct fused_bias_dropout_residual_layer_normGradNodeCompat "; } - virtual paddle::small_vector, + virtual paddle::small_vector, egr::kSlotSmallVectorSize> - operator()( - paddle::small_vector, // NOLINT - egr::kSlotSmallVectorSize>& grads, // NOLINT - bool create_graph = false, - bool is_new_grad = false) override; + operator()(paddle::small_vector, // NOLINT + egr::kSlotSmallVectorSize>& grads, // NOLINT + bool create_graph = false, + bool is_new_grad = false) override; void ClearTensorWrappers() override { Bias_.clear(); @@ -668,34 +630,32 @@ class fused_bias_dropout_residual_layer_normGradNodeCompat } // SetX, SetY, ... - void SetTensorWrapperBias(const paddle::experimental::Tensor& Bias) { + void SetTensorWrapperBias(const paddle::Tensor& Bias) { Bias_ = egr::TensorWrapper(Bias, false); } void SetTensorWrapperBiasDropoutResidualOut( - const paddle::experimental::Tensor& BiasDropoutResidualOut) { + const paddle::Tensor& BiasDropoutResidualOut) { BiasDropoutResidualOut_ = egr::TensorWrapper(BiasDropoutResidualOut, false); } - void SetTensorWrapperDropoutMaskOut( - const paddle::experimental::Tensor& DropoutMaskOut) { + void SetTensorWrapperDropoutMaskOut(const paddle::Tensor& DropoutMaskOut) { DropoutMaskOut_ = egr::TensorWrapper(DropoutMaskOut, false); } - void SetTensorWrapperLnBias(const paddle::experimental::Tensor& LnBias) { + void SetTensorWrapperLnBias(const paddle::Tensor& LnBias) { LnBias_ = egr::TensorWrapper(LnBias, false); } - void SetTensorWrapperLnMean(const paddle::experimental::Tensor& LnMean) { + void SetTensorWrapperLnMean(const paddle::Tensor& LnMean) { LnMean_ = egr::TensorWrapper(LnMean, false); } - void SetTensorWrapperLnScale(const paddle::experimental::Tensor& LnScale) { + void SetTensorWrapperLnScale(const paddle::Tensor& LnScale) { LnScale_ = egr::TensorWrapper(LnScale, false); } - void SetTensorWrapperLnVariance( - const paddle::experimental::Tensor& LnVariance) { + void SetTensorWrapperLnVariance(const paddle::Tensor& LnVariance) { LnVariance_ = egr::TensorWrapper(LnVariance, false); } - void SetTensorWrapperResidual(const paddle::experimental::Tensor& Residual) { + void SetTensorWrapperResidual(const paddle::Tensor& Residual) { Residual_ = egr::TensorWrapper(Residual, false); } - void SetTensorWrapperX(const paddle::experimental::Tensor& X) { + void SetTensorWrapperX(const paddle::Tensor& X) { X_ = egr::TensorWrapper(X, false); } diff --git a/paddle/fluid/eager/api/utils/hook_utils.cc b/paddle/fluid/eager/api/utils/hook_utils.cc index 0ac3ac4a222..36ec10d02c5 100644 --- a/paddle/fluid/eager/api/utils/hook_utils.cc +++ b/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& hook) { + const paddle::Tensor& tensor, + const std::function& hook) { // Find grad_node and out_rank from AutogradMeta std::shared_ptr 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(hook))); } -void RegisterReduceHookForTensor(const paddle::experimental::Tensor& tensor, +void RegisterReduceHookForTensor(const paddle::Tensor& tensor, const std::function& 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 weak_grad_tensor = - meta->WeakGrad(); + std::weak_ptr 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(); } }; diff --git a/paddle/fluid/eager/api/utils/hook_utils.h b/paddle/fluid/eager/api/utils/hook_utils.h index 5b3ed2633e0..f7e93dbd378 100644 --- a/paddle/fluid/eager/api/utils/hook_utils.h +++ b/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& hook); + const paddle::Tensor& tensor, + const std::function& hook); -void RegisterReduceHookForTensor(const paddle::experimental::Tensor& tensor, +void RegisterReduceHookForTensor(const paddle::Tensor& tensor, const std::function& hook); -void RetainGradForTensor(const paddle::experimental::Tensor& tensor); +void RetainGradForTensor(const paddle::Tensor& tensor); void RegisterBackwardFinalHook(const std::function& hook); diff --git a/paddle/fluid/eager/api/utils/tensor_utils.cc b/paddle/fluid/eager/api/utils/tensor_utils.cc index 2ee2938a0a0..8cc2b648e7f 100644 --- a/paddle/fluid/eager/api/utils/tensor_utils.cc +++ b/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 grad_node = EagerUtils::grad_node(target); if (!grad_node || std::dynamic_pointer_cast(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); diff --git a/paddle/fluid/eager/api/utils/tensor_utils.h b/paddle/fluid/eager/api/utils/tensor_utils.h index daffee4b39f..8f25e40392d 100644 --- a/paddle/fluid/eager/api/utils/tensor_utils.h +++ b/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 diff --git a/paddle/fluid/eager/auto_code_generator/eager_generator.cc b/paddle/fluid/eager/auto_code_generator/eager_generator.cc index 5915494ebc3..1f6e6427e37 100644 --- a/paddle/fluid/eager/auto_code_generator/eager_generator.cc +++ b/paddle/fluid/eager/auto_code_generator/eager_generator.cc @@ -1438,10 +1438,10 @@ static std::pair GenerateForwardFunctionContents( Controller.Instance().GetExpectedPlace(), {}); // According to fwd_outputs_names - std::vector Out0 = + std::vector Out0 = GetOutputs(outs["Out0"]); - paddle::experimental::Tensor Out1 = GetOutputs(outs["Out1"][0]); - std::vector Out2 = + paddle::Tensor Out1 = GetOutputs(outs["Out1"][0]); + std::vector Out2 = GetOutputs(outs["Out2"]); // Grad Node Generation Codes @@ -1480,7 +1480,7 @@ static std::pair GenerateForwardFunctionContents( if (input.duplicable()) { const char* FWD_INS_ARG_TEMPLATE = - "const std::vector& %s"; + "const std::vector& %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 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 GenerateForwardFunctionContents( // argument(EagerVariable*/vector&), // in form of shared_ptr/vector> if (output.duplicable()) { - const char* FWD_NUM_ARG_TEMPLATE = - ", std::vector& %s"; + const char* FWD_NUM_ARG_TEMPLATE = ", std::vector& %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 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 GenerateForwardFunctionContents( std::string amp_logic_str = ""; if (in_vars.size() != 0) { const char* AMP_TENSORS_VECTOR_TEMPLATE = - " paddle::small_vector, " + " paddle::small_vector, " "egr::kSlotSmallVectorSize> " "amp_tensors_vector = { " "%s };\n"; @@ -1897,7 +1896,7 @@ static std::pair GenerateForwardFunctionContents( if (op_passing_outs_map[op_type].count(output_name)) { if (output.dispensable()) { const char* FWD_OUT_TENSORS_TEMPLATE = - " std::vector %s;\n" + " std::vector %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 GenerateForwardFunctionContents( output_varname); } else { const char* FWD_OUT_TENSORS_TEMPLATE = - " std::vector %s;\n" + " std::vector %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 GenerateForwardFunctionContents( } } else { const char* FWD_OUT_TENSORS_TEMPLATE = - " std::vector %s;\n" + " std::vector %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"; + return_types[return_position] = "std::vector"; } 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 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 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 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, " + " paddle::small_vector, " "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> outputs(outs.size()); + vector> 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, " + " paddle::small_vector, " "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, " + "paddle::small_vector, " "egr::kSlotSmallVectorSize> " "%sGradNodeCompat::operator()(" - "paddle::small_vector, " + "paddle::small_vector, " "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, " + "paddle::small_vector, " "egr::kSlotSmallVectorSize> " "operator()(" - "paddle::small_vector, " + "paddle::small_vector, " "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& %s"; + "const std::vector& %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); diff --git a/paddle/fluid/eager/auto_code_generator/generator/eager_gen.py b/paddle/fluid/eager/auto_code_generator/generator/eager_gen.py index 8a5e2aef19b..a973fb3a9ca 100644 --- a/paddle/fluid/eager/auto_code_generator/generator/eager_gen.py +++ b/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& {}) {{ +SET_VECTOR_TENSOR_WRAPPER_TEMPLATE = """ void SetTensorWrapper{}(const std::vector& {}) {{ 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, egr::kSlotSmallVectorSize> operator()( - paddle::small_vector, egr::kSlotSmallVectorSize>& grads, bool create_graph = false, bool is_new_grad = false) override; + virtual paddle::small_vector, egr::kSlotSmallVectorSize> operator()( + paddle::small_vector, 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, egr::kSlotSmallVectorSize> {}::operator()(paddle::small_vector, egr::kSlotSmallVectorSize>& grads, bool create_graph, bool is_new_grad) {{ +paddle::small_vector, egr::kSlotSmallVectorSize> {}::operator()(paddle::small_vector, 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, egr::kSlotSmallVectorSize> amp_tensors_vector = {}; + paddle::small_vector, 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, egr::kSlotSmallVectorSize> tensors_vector = {}; + paddle::small_vector, 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 {}_optional; - if({}.initialized()) {}_optional = paddle::make_optional({}); + paddle::optional {}_optional; + if({}.initialized()) {}_optional = paddle::make_optional({}); """ CREATE_RECOVER_OPTIONAL_TENSOR_TEMPLATE = """ - paddle::optional {}_optional; - if( {}.impl() ) {}_optional = paddle::make_optional({}); + paddle::optional {}_optional; + if( {}.impl() ) {}_optional = paddle::make_optional({}); """ CREATE_RECOVER_OPTIONAL_VECTOR_TENSOR_TEMPLATE = """ - paddle::optional> {}_optional; - if( !{}.empty() ) {}_optional = paddle::make_optional>({}); + paddle::optional> {}_optional; + if( !{}.empty() ) {}_optional = paddle::make_optional>({}); """ 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&", - "std::vector": "paddle::optional>&", + "Tensor": "paddle::optional&", + "std::vector": "paddle::optional>&", } @@ -1282,9 +1282,11 @@ class DygraphForwardFunctionGenerator(DygraphFunctionGeneratorBase): and forward_inplace_map and name in forward_inplace_map.keys() ): - arg_str = f"paddle::optional& {name}" + arg_str = f"paddle::optional& {name}" else: - arg_str = f"const paddle::optional& {name}" + arg_str = ( + f"const paddle::optional& {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>& {name}" + arg_str = f"paddle::optional>& {name}" else: - arg_str = f"const paddle::optional>& {name}" + arg_str = f"const paddle::optional>& {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& {name}" - ) + arg_str = f"std::vector& {name}" else: - arg_str = f"const std::vector& {name}" + arg_str = f"const std::vector& {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&" + returns_type_list[pos] = "std::vector&" else: - returns_type_list[ - pos - ] = "std::vector" + returns_type_list[pos] = "std::vector" 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, egr::kSlotSmallVectorSize> returns({slot_num_bwd_outputs}); + paddle::small_vector, 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 api_output_{out_index}; + std::vector 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 = "" + composite_template_name = "" if is_invoke_forward_api: autograd_api_out = "auto" diff --git a/paddle/fluid/eager/autograd_meta.h b/paddle/fluid/eager/autograd_meta.h index 4d8b5ec9daa..fc29d41077d 100644 --- a/paddle/fluid/eager/autograd_meta.h +++ b/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 WeakGrad() { return grad_; } + std::weak_ptr WeakGrad() { return grad_; } void SetGradNode(const std::shared_ptr& 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 grad_{ - std::make_shared()}; + std::shared_ptr grad_{std::make_shared()}; // GradNodeBase is base class of all grad op which is a // wrapper for grad op. This class will make grad op easy diff --git a/paddle/fluid/eager/backward.cc b/paddle/fluid/eager/backward.cc index 15c67f451be..9361b7e232f 100644 --- a/paddle/fluid/eager/backward.cc +++ b/paddle/fluid/eager/backward.cc @@ -82,8 +82,7 @@ void EnforceGradNodeHasInput(GradNodeBase* node) { node->name())); } -void DuplicateCheck(const std::vector& inputs, - bool is_input) { +void DuplicateCheck(const std::vector& inputs, bool is_input) { std::unordered_set visisted_ins; std::string msg = is_input ? "inputs" : "outputs"; for (auto in : inputs) { @@ -102,14 +101,14 @@ void DuplicateCheck(const std::vector& inputs, GeneralGrad* GeneralGrad::general_grad_ = new GeneralGrad(); -std::vector RunBackward( - const std::vector& tensors, // output - const std::vector& grad_tensors, +std::vector RunBackward( + const std::vector& tensors, // output + const std::vector& grad_tensors, bool retain_graph, bool create_graph = false, - const std::vector& inputs = {}, + const std::vector& inputs = {}, bool allow_unused = false, - const std::vector& no_grad_vars = {}) { + const std::vector& no_grad_vars = {}) { VLOG(3) << "Start Backward"; // *Gradient Hook should happen at node-level @@ -128,7 +127,7 @@ std::vector RunBackward( std::unordered_map> 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 RunBackward( VLOG(7) << "Run Backward Kernel with GradTensorHolder."; // Run Pre Backward Node and get outputs - paddle::small_vector, - kSlotSmallVectorSize> + paddle::small_vector, kSlotSmallVectorSize> grad_output_tensors = (*node)( node_input_buffer->Buffers(), create_graph, is_general_grad); @@ -315,8 +313,7 @@ std::vector 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 RunBackward( return GeneralGrad::Instance().GetResults(inputs, allow_unused, create_graph); } -void Backward( - const std::vector& tensors, // outputs - const std::vector& grad_tensors, - bool retain_graph) { +void Backward(const std::vector& tensors, // outputs + const std::vector& 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 Grad( - const std::vector& tensors, // outputs - const std::vector& inputs, - const std::vector& grad_tensors, +std::vector Grad( + const std::vector& tensors, // outputs + const std::vector& inputs, + const std::vector& grad_tensors, bool retain_graph, bool create_graph, bool only_inputs, bool allow_unused, - const std::vector& no_grad_vars) { + const std::vector& no_grad_vars) { VLOG(3) << "Run in Grad"; DuplicateCheck(inputs, true /* is_input */); diff --git a/paddle/fluid/eager/backward.h b/paddle/fluid/eager/backward.h index e977271ff42..2baccfc5577 100644 --- a/paddle/fluid/eager/backward.h +++ b/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& tensors, - const std::vector& grad_tensors, +void Backward(const std::vector& tensors, + const std::vector& grad_tensors, bool retain_graph = false); -std::vector Grad( - const std::vector& tensors, - const std::vector& inputs, - const std::vector& grad_tensors = {}, +std::vector Grad( + const std::vector& tensors, + const std::vector& inputs, + const std::vector& grad_tensors = {}, bool retain_graph = false, bool create_graph = false, bool only_inputs = false, bool allow_unused = false, - const std::vector& no_grad_vars = {}); + const std::vector& no_grad_vars = {}); // Reserved for gradient() diff --git a/paddle/fluid/eager/custom_operator/custom_operator_node.cc b/paddle/fluid/eager/custom_operator/custom_operator_node.cc index f70b402b566..df959759816 100644 --- a/paddle/fluid/eager/custom_operator/custom_operator_node.cc +++ b/paddle/fluid/eager/custom_operator/custom_operator_node.cc @@ -164,13 +164,11 @@ static void ConstructFwdAndBwdMap( } } -paddle::small_vector, - kSlotSmallVectorSize> -RunCustomOpNode::operator()( - paddle::small_vector, - kSlotSmallVectorSize>& grads, - bool create_graph, - bool is_new_grad) { // NOLINT +paddle::small_vector, kSlotSmallVectorSize> +RunCustomOpNode::operator()(paddle::small_vector, + 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, - kSlotSmallVectorSize> + paddle::small_vector, 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, - kSlotSmallVectorSize> - outs(OutputMeta().size()); - paddle::small_vector, - kSlotSmallVectorSize> + paddle::small_vector, kSlotSmallVectorSize> outs( + OutputMeta().size()); + paddle::small_vector, 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& in_tensors = - ctx.InputsBetween(ctx.InputRangeAt(i).first, - ctx.InputRangeAt(i).second); + const std::vector& 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& out_tensors = - ctx.OutputsBetweeen(ctx.OutputRangeAt(i).first, - ctx.OutputRangeAt(i).second); + const std::vector& 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, - kSlotSmallVectorSize> +paddle::small_vector, kSlotSmallVectorSize> RunCustomOpDoubleGradNode::operator()( - paddle::small_vector, - kSlotSmallVectorSize>& grads, + paddle::small_vector, 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, - kSlotSmallVectorSize> + paddle::small_vector, 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, - kSlotSmallVectorSize> - outs(OutputMeta().size()); - paddle::small_vector, - kSlotSmallVectorSize> + paddle::small_vector, kSlotSmallVectorSize> outs( + OutputMeta().size()); + paddle::small_vector, kSlotSmallVectorSize> tmp_outs(grad_outputs_names.size()); VLOG(6) << "Prepare Grad outputs for size: " << grad_outputs_names.size(); diff --git a/paddle/fluid/eager/custom_operator/custom_operator_node.h b/paddle/fluid/eager/custom_operator/custom_operator_node.h index d5df505eeca..ff57968d413 100644 --- a/paddle/fluid/eager/custom_operator/custom_operator_node.h +++ b/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, + virtual paddle::small_vector, kSlotSmallVectorSize> operator()( // NOLINT - paddle::small_vector, + paddle::small_vector, kSlotSmallVectorSize>& grads, // NOLINT bool create_graph = false, bool is_new_grad = false) // NOLINT @@ -51,7 +51,7 @@ class RunCustomOpNode : public GradNodeBase { } static std::vector ConstructTensorWrapper( - const std::vector& fwd_var) { + const std::vector& fwd_var) { std::vector res; for (auto const& var : fwd_var) { res.emplace_back(var); @@ -59,9 +59,9 @@ class RunCustomOpNode : public GradNodeBase { return res; } - static std::vector Recover( + static std::vector Recover( std::vector* fwd_var) { - std::vector res; + std::vector 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, + virtual paddle::small_vector, kSlotSmallVectorSize> operator()( // NOLINT - paddle::small_vector, + paddle::small_vector, kSlotSmallVectorSize>& grads, // NOLINT bool create_graph = false, bool is_new_grad = false) // NOLINT @@ -122,7 +122,7 @@ class RunCustomOpDoubleGradNode : public GradNodeBase { } static std::vector ConstructTensorWrapper( - const std::vector& fwd_var) { + const std::vector& fwd_var) { std::vector res; for (auto const& var : fwd_var) { res.emplace_back(var); @@ -130,9 +130,9 @@ class RunCustomOpDoubleGradNode : public GradNodeBase { return res; } - static std::vector Recover( + static std::vector Recover( std::vector* fwd_var) { - std::vector res; + std::vector res; for (size_t i = 0; i < fwd_var->size(); i++) { res.emplace_back(fwd_var->at(i).recover()); } diff --git a/paddle/fluid/eager/eager_amp_auto_cast.h b/paddle/fluid/eager/eager_amp_auto_cast.h index e80daf69d9c..e9673f4905e 100644 --- a/paddle/fluid/eager/eager_amp_auto_cast.h +++ b/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 EagerAmpAutoCasts( +inline std::vector EagerAmpAutoCasts( const std::string& inputs_name, - const std::vector& inputs, + const std::vector& 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 inputs_casted; + std::vector 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 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 EagerAmpAutoCast( +inline paddle::optional EagerAmpAutoCast( const std::string& input_name, - const paddle::optional& input, + const paddle::optional& input, const paddle::experimental::DataType& dst_dtype, const std::string& op_name, bool trace_backward = true) { @@ -132,10 +131,9 @@ inline paddle::optional EagerAmpAutoCast( return paddle::none; } -inline paddle::optional> -EagerAmpAutoCasts( +inline paddle::optional> EagerAmpAutoCasts( const std::string& inputs_name, - const paddle::optional>& inputs, + const paddle::optional>& 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>(); + return paddle::optional>(); } } // namespace egr diff --git a/paddle/fluid/eager/eager_layout_auto_tune.h b/paddle/fluid/eager/eager_layout_auto_tune.h index 7add326eee9..8d8cdfa0e2f 100644 --- a/paddle/fluid/eager/eager_layout_auto_tune.h +++ b/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, + const paddle::small_vector, 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 EagerLayoutAutotune( const std::string& op_name, - const paddle::small_vector, + const paddle::small_vector, 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 EagerLayoutAutotune( template inline std::shared_ptr EagerLayoutAutotune( const std::string& op_name, - const paddle::small_vector, + const paddle::small_vector, kSlotSmallVectorSize>& tensors_vector, T* attr) { // For lightly op like reduce @@ -78,7 +78,7 @@ inline std::shared_ptr EagerLayoutAutotune( template inline std::shared_ptr EagerLayoutAutotune( const std::string& op_name, - const paddle::small_vector, + const paddle::small_vector, kSlotSmallVectorSize>& tensors_vector, T1* axis, T2* keep_dim) { @@ -89,7 +89,7 @@ inline std::shared_ptr EagerLayoutAutotune( template <> inline std::shared_ptr EagerLayoutAutotune( const std::string& op_name, - const paddle::small_vector, + const paddle::small_vector, kSlotSmallVectorSize>& tensors_vector, std::string* attr) { // Heavily op with (string) data_format, data_layout @@ -142,7 +142,7 @@ inline std::shared_ptr EagerLayoutAutotune( template <> inline std::shared_ptr EagerLayoutAutotune( const std::string& op_name, - const paddle::small_vector, + const paddle::small_vector, kSlotSmallVectorSize>& tensors_vector, std::vector* attr) { // lightly transpose @@ -167,7 +167,7 @@ template <> inline std::shared_ptr EagerLayoutAutotune( const std::string& op_name, - const paddle::small_vector, + const paddle::small_vector, kSlotSmallVectorSize>& tensors_vector, paddle::experimental::Scalar* axis, bool* keep_dim) { @@ -191,7 +191,7 @@ EagerLayoutAutotune( template <> inline std::shared_ptr EagerLayoutAutotune( const std::string& op_name, - const paddle::small_vector, + const paddle::small_vector, kSlotSmallVectorSize>& tensors_vector, int* start_axis, int* stop_axis) { @@ -215,7 +215,7 @@ template <> inline std::shared_ptr EagerLayoutAutotune( const std::string& op_name, - const paddle::small_vector, + const paddle::small_vector, kSlotSmallVectorSize>& tensors_vector, paddle::experimental::Scalar* axis) { if (DesiredLayout() == phi::DataLayout::UNDEFINED) { diff --git a/paddle/fluid/eager/eager_layout_transformer.h b/paddle/fluid/eager/eager_layout_transformer.h index 07d84ebef55..ce80f6c948a 100644 --- a/paddle/fluid/eager/eager_layout_transformer.h +++ b/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, + const paddle::small_vector, 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 TransInTensor( - const std::string& in_name, - const paddle::optional& in) { + virtual paddle::optional TransInTensor( + const std::string& in_name, const paddle::optional& in) { return in ? TransInTensor(in_name, *in) : in; } - virtual std::vector TransInTensors( - const std::string& in_name, - const std::vector& in) { + virtual std::vector TransInTensors( + const std::string& in_name, const std::vector& in) { return in; } - virtual paddle::optional> - TransInTensors( + virtual paddle::optional> TransInTensors( const std::string& in_name, - const paddle::optional>& in) { + const paddle::optional>& in) { return (in ? TransInTensors(in_name, *in) : in); } - virtual void SetOutTensorLayout( - std::vector* out_tensor) { + virtual void SetOutTensorLayout(std::vector* 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* out_tensor) { + paddle::optional* out_tensor) { VLOG(4) << "AutoTune out tensor is optional"; } virtual void SetOutTensorLayout( - paddle::optional>* out_tensor) { + paddle::optional>* 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* out_tensor) { + void SetOutTensorLayout(std::vector* out_tensor) { for (size_t i = 0; i < out_tensor->size(); i++) { SetOutTensorLayout((*out_tensor)[i]); } } - void SetOutTensorLayout( - std::vector* out_tensor) { + void SetOutTensorLayout(std::vector* 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 TransInTensors( - const std::string& in_name, - const std::vector& in) { - std::vector result; + virtual std::vector TransInTensors( + const std::string& in_name, const std::vector& in) { + std::vector 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* out_tensor) { + void SetOutTensorLayout(std::vector* out_tensor) { for (size_t i = 0; i < out_tensor->size(); i++) { SetOutTensorLayout((*out_tensor)[i]); } } - void SetOutTensorLayout( - std::vector* out_tensor) { + void SetOutTensorLayout(std::vector* 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(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(perm[axes]); } - virtual std::vector TransInTensors( - const std::string& in_name, - const std::vector& in) { + virtual std::vector TransInTensors( + const std::string& in_name, const std::vector& in) { return in; } - void SetOutTensorLayout(paddle::experimental::Tensor* out_tensor) { + void SetOutTensorLayout(paddle::Tensor* out_tensor) { UpdateLayout(out_tensor, DesiredLayout()); } }; diff --git a/paddle/fluid/eager/eager_tensor.h b/paddle/fluid/eager/eager_tensor.h index 15fbb192a84..ae9030118a9 100644 --- a/paddle/fluid/eager/eager_tensor.h +++ b/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, unordered_map, these type cannot * cover by DenseTensor or SparseTensor. So, we have to provide a compatible @@ -178,22 +178,22 @@ class VariableCompatTensor std::shared_ptr 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(tensor); @@ -283,7 +282,7 @@ class EagerVariable final { } template - void ConstructVariableFromTensor(const paddle::experimental::Tensor& tensor) { + void ConstructVariableFromTensor(const paddle::Tensor& tensor) { auto* framework_tensor = var_.GetMutable(); // Contruct phi::DenseTensor from egr::EagerVariable auto tensor_dense = std::dynamic_pointer_cast(tensor.impl()); @@ -299,8 +298,7 @@ class EagerVariable final { } template - void ConstructVariableFromCompatTensor( - const paddle::experimental::Tensor& tensor) { + void ConstructVariableFromCompatTensor(const paddle::Tensor& tensor) { auto* framework_holder = var_.GetMutable(); // Contruct phi::DenseTensor from egr::EagerVariable auto* compat_tensor = diff --git a/paddle/fluid/eager/general_grad.h b/paddle/fluid/eager/general_grad.h index 142624a9d95..945198e4c7f 100644 --- a/paddle/fluid/eager/general_grad.h +++ b/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& inputs, - bool is_no_grad_vars) { + void GetTargetNodesInfo(const std::vector& 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(target_result); + std::make_shared(target_result); } } } // TODO(jiabin): Some check here. } void SetResultForEnddingNodes( - paddle::small_vector, - kSlotSmallVectorSize> grad_output, + paddle::small_vector, 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(grad_output[0][0]); + results_map_[node] = std::make_shared(grad_output[0][0]); } } - std::shared_ptr FetchGradForTensor( - const paddle::experimental::Tensor& tensor, - egr::GradNodeBase* target_node) { - std::shared_ptr tmp{ - std::make_shared()}; + std::shared_ptr FetchGradForTensor( + const paddle::Tensor& tensor, egr::GradNodeBase* target_node) { + std::shared_ptr tmp{std::make_shared()}; 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& inputs) { + void RegisterFetchGradHook(const std::vector& inputs) { VLOG(6) << "Running in RegisterFetchGradHook."; if (!inputs.empty()) { size_t num_inputs = inputs.size(); @@ -436,14 +431,14 @@ class GeneralGrad { } } - std::vector GetResults( - const std::vector& inputs, + std::vector GetResults( + const std::vector& inputs, bool allow_unused, bool create_graph) { VLOG(6) << "Running in GetResults"; if (inputs.empty()) return {}; - std::vector results; + std::vector 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& inputs, - const std::vector& no_grad_vars, + const std::vector& inputs, + const std::vector& no_grad_vars, const std::deque& orig_queue, std::deque* queue, const std::unordered_map /* pre nodes */> depending_nodes_; - std::unordered_map> + std::unordered_map> results_map_; std::vector> copied_grad_nodes_; diff --git a/paddle/fluid/eager/grad_node_info.cc b/paddle/fluid/eager/grad_node_info.cc index d0a1d45b443..f3587077d33 100644 --- a/paddle/fluid/eager/grad_node_info.cc +++ b/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& fwd_out, - size_t slot_rank) { +void GradNodeBase::SetGradInMeta(const std::vector& 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& fwd_in, size_t slot_rank) { +void GradNodeBase::SetGradOutMeta(const std::vector& 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& fwd_in, - size_t slot_rank) { + const std::vector& 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, - kSlotSmallVectorSize> +paddle::small_vector, kSlotSmallVectorSize> GradNodeBase::ApplyGradientHooks( - const paddle::small_vector, + const paddle::small_vector, kSlotSmallVectorSize>& tensors) { - paddle::small_vector, - kSlotSmallVectorSize> - outs(tensors.size()); + paddle::small_vector, 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& slot_out = outs[slot_id]; + std::vector& 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, - kSlotSmallVectorSize>* out_grads) { + paddle::small_vector, kSlotSmallVectorSize>* + out_grads) { for (size_t slot_id = 0; slot_id < out_grads->size(); slot_id++) { - const std::vector& slot_out_grads = - (*out_grads)[slot_id]; + const std::vector& 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; diff --git a/paddle/fluid/eager/grad_node_info.h b/paddle/fluid/eager/grad_node_info.h index de458db1234..7fdd85fa086 100644 --- a/paddle/fluid/eager/grad_node_info.h +++ b/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}, * so, vector of vector is better choice to fit this format. * **/ - virtual paddle::small_vector, + virtual paddle::small_vector, kSlotSmallVectorSize> - operator()(paddle::small_vector, + operator()(paddle::small_vector, 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& fwd_out, - size_t slot_rank); - void SetGradInMeta(const paddle::experimental::Tensor& fwd_out, + void SetGradInMeta(const std::vector& fwd_out, size_t slot_rank); + void SetGradInMeta(const paddle::Tensor& fwd_out, size_t slot_rank); - void SetGradOutMeta(const std::vector& fwd_in, + void SetGradOutMeta(const std::vector& fwd_in, size_t slot_rank); - void SetGradOutMeta( - const std::vector& fwd_in, - size_t slot_rank); - void SetGradOutMeta(const paddle::experimental::Tensor& fwd_in, + void SetGradOutMeta(const std::vector& 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, - kSlotSmallVectorSize> - ApplyGradientHooks( - const paddle::small_vector, - kSlotSmallVectorSize>& tensors); + paddle::small_vector, kSlotSmallVectorSize> + ApplyGradientHooks(const paddle::small_vector, + kSlotSmallVectorSize>& tensors); /** * Handle Complex - Real Type Promotion * **/ void HandleComplexGradToRealGrad( - paddle::small_vector, - kSlotSmallVectorSize>* out_grads); + paddle::small_vector, kSlotSmallVectorSize>* + out_grads); bool NeedComplexToRealConversion() { return need_complex_to_real_; } virtual std::string name() { return "GradNodeBase"; } diff --git a/paddle/fluid/eager/grad_tensor_holder.cc b/paddle/fluid/eager/grad_tensor_holder.cc index 56268924b50..199dfaf820f 100644 --- a/paddle/fluid/eager/grad_tensor_holder.cc +++ b/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( - t, &buffer_tensor); + paddle::imperative::TensorAdd(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(), "tmp_accumulator"); + paddle::Tensor new_buffer(std::make_shared(), + "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(t.impl()); - paddle::experimental::Tensor t_values( + paddle::Tensor t_values( std::make_shared(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( buffer_tensor.impl()); - paddle::experimental::Tensor buffer_values( - std::make_shared( - buffer_sparse->non_zero_elements())); + paddle::Tensor buffer_values(std::make_shared( + 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( - t_values, &buffer_values); + paddle::imperative::TensorAdd(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( + t, buffer_tensor)); } } } diff --git a/paddle/fluid/eager/grad_tensor_holder.h b/paddle/fluid/eager/grad_tensor_holder.h index 687e840b4c2..05b200fbb56 100644 --- a/paddle/fluid/eager/grad_tensor_holder.h +++ b/paddle/fluid/eager/grad_tensor_holder.h @@ -39,9 +39,8 @@ class GradTensorHolder { GradTensorHolder(const GradTensorHolder& other) = default; - explicit GradTensorHolder( - paddle::small_vector, - kSlotSmallVectorSize>&& inputs) + explicit GradTensorHolder(paddle::small_vector, + 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& operator[]( - const size_t& pos) { + const std::vector& operator[](const size_t& pos) { return buffer_[pos]; } - paddle::small_vector, - kSlotSmallVectorSize>& + paddle::small_vector, kSlotSmallVectorSize>& Buffers() { return buffer_; } @@ -70,8 +67,7 @@ class GradTensorHolder { void SetBufferSlotRankZeros(size_t slot_id, size_t rank); private: - paddle::small_vector, - kSlotSmallVectorSize> + paddle::small_vector, kSlotSmallVectorSize> buffer_; }; diff --git a/paddle/fluid/eager/hooks.h b/paddle/fluid/eager/hooks.h index ff2ca4aef13..51e13d533d3 100644 --- a/paddle/fluid/eager/hooks.h +++ b/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& fn) + explicit CppTensorHook( + const std::function& 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 - fn_; + std::function fn_; }; class CppVoidHook : public VoidHook { @@ -76,14 +72,14 @@ class PackHookBase { public: virtual ~PackHookBase() = default; virtual std::shared_ptr 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 packed_value) = 0; virtual void* operator()(void* packed_value, void* other) = 0; }; diff --git a/paddle/fluid/eager/nan_inf_utils.cc b/paddle/fluid/eager/nan_inf_utils.cc index e15b91e480a..cc09ebb6c5d 100644 --- a/paddle/fluid/eager/nan_inf_utils.cc +++ b/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, + const paddle::small_vector, egr::kSlotSmallVectorSize>& tensors) { for (auto& tensor_vector : tensors) { CheckTensorHasNanOrInf(api_name, tensor_vector); diff --git a/paddle/fluid/eager/nan_inf_utils.h b/paddle/fluid/eager/nan_inf_utils.h index 9abc1ca02f1..cb19fd2f9d7 100644 --- a/paddle/fluid/eager/nan_inf_utils.h +++ b/paddle/fluid/eager/nan_inf_utils.h @@ -24,7 +24,7 @@ namespace egr { -using paddle::experimental::Tensor; +using paddle::Tensor; using TupleOfTwoTensors = std::tuple; using TupleOfThreeTensors = std::tuple; using TupleOfFourTensors = std::tuple; @@ -59,7 +59,7 @@ void CheckTensorHasNanOrInf(const std::string& api_name, void CheckTensorHasNanOrInf( const std::string& api_name, - const paddle::small_vector, + const paddle::small_vector, egr::kSlotSmallVectorSize>& tensors); template diff --git a/paddle/fluid/eager/pylayer/py_layer_node.cc b/paddle/fluid/eager/pylayer/py_layer_node.cc index 0e89bab9a08..e601f17d88f 100644 --- a/paddle/fluid/eager/pylayer/py_layer_node.cc +++ b/paddle/fluid/eager/pylayer/py_layer_node.cc @@ -32,18 +32,16 @@ GradNodePyLayer::~GradNodePyLayer() { Py_XDECREF(ctx_); } -paddle::small_vector, - kSlotSmallVectorSize> +paddle::small_vector, kSlotSmallVectorSize> GradNodePyLayer::operator()( - paddle::small_vector, + paddle::small_vector, 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, - kSlotSmallVectorSize> + paddle::small_vector, 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(); 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(); 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, - kSlotSmallVectorSize> + paddle::small_vector, 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++) { diff --git a/paddle/fluid/eager/pylayer/py_layer_node.h b/paddle/fluid/eager/pylayer/py_layer_node.h index 5eee2f15c1b..ac6fc291406 100644 --- a/paddle/fluid/eager/pylayer/py_layer_node.h +++ b/paddle/fluid/eager/pylayer/py_layer_node.h @@ -48,9 +48,9 @@ class GradNodePyLayer : public GradNodeBase { ~GradNodePyLayer() override; - virtual paddle::small_vector, + virtual paddle::small_vector, kSlotSmallVectorSize> - operator()(paddle::small_vector, + operator()(paddle::small_vector, 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>& - outputs_tensor) { + const std::vector>& 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++) { diff --git a/paddle/fluid/eager/tensor_wrapper.h b/paddle/fluid/eager/tensor_wrapper.h index cb797c18b19..63bb7374d9a 100644 --- a/paddle/fluid/eager/tensor_wrapper.h +++ b/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 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 weak_grad_node_; uint32_t inplace_version_snapshot_ = 0; #ifndef PADDLE_NO_PYTHON diff --git a/paddle/fluid/eager/tests/data_structure_tests/accumulation_node_test.cc b/paddle/fluid/eager/tests/data_structure_tests/accumulation_node_test.cc index ecc0e0fe667..d3b676009cb 100644 --- a/paddle/fluid/eager/tests/data_structure_tests/accumulation_node_test.cc +++ b/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(paddle::platform::CPUPlace())[0] = static_cast(10.0f); - paddle::experimental::Tensor et0 = paddle::experimental::Tensor(sr0); + paddle::Tensor et0 = paddle::Tensor(sr0); std::shared_ptr dt1 = std::make_shared( std::make_unique( paddle::platform::CPUPlace()) @@ -47,15 +47,14 @@ TEST(AccumulationNode, SelectedRowsAddToTensor) { meta); dt1->mutable_data(paddle::platform::CPUPlace())[0] = static_cast(20.0f); - paddle::experimental::Tensor et1 = paddle::experimental::Tensor(dt1); + paddle::Tensor et1 = paddle::Tensor(dt1); std::shared_ptr input_dt = std::make_shared( std::make_unique( 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 grad_dt = @@ -69,19 +68,17 @@ TEST(AccumulationNode, SelectedRowsAddToTensor) { grad_meta->SetGradNode(node); grad_meta->SetStopGradient(false); // operator() - paddle::small_vector, - kSlotSmallVectorSize> + paddle::small_vector, 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(ret_et0.impl()) ->value() .data(); CHECK_EQ(ret_et0_ptr[0], static_cast(10.0f)); - paddle::small_vector, - kSlotSmallVectorSize> + paddle::small_vector, 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(ret_et1.impl()) ->data(); @@ -91,7 +88,7 @@ TEST(AccumulationNode, SelectedRowsAddToTensor) { ->value() .data()[0], static_cast(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(grad->impl())->data(); CHECK_EQ(grad_ptr[0], static_cast(30.0f)); @@ -107,21 +104,20 @@ TEST(AccumulationNode, SelectedRowsMerge) { sr0->mutable_value()->Resize(phi::make_ddim({1, 1})); sr0->mutable_value()->mutable_data(paddle::platform::CPUPlace())[0] = static_cast(10.0f); - paddle::experimental::Tensor et0 = paddle::experimental::Tensor(sr0); + paddle::Tensor et0 = paddle::Tensor(sr0); std::shared_ptr sr1 = std::make_shared(rows, 1); sr1->mutable_value()->Resize(phi::make_ddim({1, 1})); sr1->mutable_value()->mutable_data(paddle::platform::CPUPlace())[0] = static_cast(20.0f); - paddle::experimental::Tensor et1 = paddle::experimental::Tensor(sr1); + paddle::Tensor et1 = paddle::Tensor(sr1); std::shared_ptr input_dt = std::make_shared( std::make_unique( 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 grad_dt = @@ -135,19 +131,17 @@ TEST(AccumulationNode, SelectedRowsMerge) { grad_meta->SetGradNode(node); grad_meta->SetStopGradient(false); // operator() - paddle::small_vector, - kSlotSmallVectorSize> + paddle::small_vector, 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(ret_et0.impl()) ->value() .data(); CHECK_EQ(ret_et0_ptr[0], static_cast(10.0f)); - paddle::small_vector, - kSlotSmallVectorSize> + paddle::small_vector, 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(ret_et1.impl()) ->value() @@ -158,7 +152,7 @@ TEST(AccumulationNode, SelectedRowsMerge) { ->value() .data()[0], static_cast(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(grad->impl()) ->value() .data(); @@ -175,21 +169,20 @@ TEST(AccumulationNode, SelectedRowsAddTensor) { sr0->mutable_value()->Resize(phi::make_ddim({1, 1})); sr0->mutable_value()->mutable_data(paddle::platform::CPUPlace())[0] = static_cast(10.0f); - paddle::experimental::Tensor et0 = paddle::experimental::Tensor(sr0); + paddle::Tensor et0 = paddle::Tensor(sr0); std::shared_ptr sr1 = std::make_shared(rows, 1); sr1->mutable_value()->Resize(phi::make_ddim({1, 1})); sr1->mutable_value()->mutable_data(paddle::platform::CPUPlace())[0] = static_cast(20.0f); - paddle::experimental::Tensor et1 = paddle::experimental::Tensor(sr1); + paddle::Tensor et1 = paddle::Tensor(sr1); std::shared_ptr input_dt = std::make_shared( std::make_unique( 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 grad_dt = @@ -206,19 +199,17 @@ TEST(AccumulationNode, SelectedRowsAddTensor) { grad_meta->SetGradNode(node); grad_meta->SetStopGradient(false); // operator() - paddle::small_vector, - kSlotSmallVectorSize> + paddle::small_vector, 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(ret_et0.impl()) ->value() .data(); CHECK_EQ(ret_et0_ptr[0], static_cast(10.0f)); - paddle::small_vector, - kSlotSmallVectorSize> + paddle::small_vector, 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(ret_et1.impl()) ->value() @@ -229,7 +220,7 @@ TEST(AccumulationNode, SelectedRowsAddTensor) { ->value() .data()[0], static_cast(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(grad->impl())->data(); CHECK_EQ(grad_ptr[0], static_cast(30.0f)); @@ -246,7 +237,7 @@ TEST(AccumulationNode, Tensor) { meta); dt0->mutable_data( 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 dt1 = std::make_shared( std::make_unique( @@ -256,7 +247,7 @@ TEST(AccumulationNode, Tensor) { dt1->mutable_data( 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 input_dt = std::make_shared( @@ -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, - kSlotSmallVectorSize> + paddle::small_vector, 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(ret_et0.impl()) ->data(); CHECK_EQ(ret_et0_ptr[0], paddle::platform::float16(10.0f)); - paddle::small_vector, - kSlotSmallVectorSize> + paddle::small_vector, 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(ret_et1.impl()) @@ -308,7 +296,7 @@ TEST(AccumulationNode, Tensor) { CHECK_EQ(std::dynamic_pointer_cast(et0.impl()) ->data()[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(grad->impl()) ->data(); CHECK_EQ(grad_ptr[0], paddle::platform::float16(30.0f)); @@ -331,7 +319,7 @@ TEST(AccumulationNode, Tensor) { node->RegisterReduceHook(std::make_shared(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(_ret.impl()) diff --git a/paddle/fluid/eager/tests/data_structure_tests/autograd_meta_test.cc b/paddle/fluid/eager/tests/data_structure_tests/autograd_meta_test.cc index f7415dd1f71..f588f8c8c75 100644 --- a/paddle/fluid/eager/tests/data_structure_tests/autograd_meta_test.cc +++ b/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(); et1.set_autograd_meta(auto_grad); auto* tmp_auto = static_cast(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(); et1.set_autograd_meta(auto_grad); auto* tmp_auto = static_cast(et1.get_autograd_meta()); diff --git a/paddle/fluid/eager/tests/data_structure_tests/eager_tensor_test.cc b/paddle/fluid/eager/tests/data_structure_tests/eager_tensor_test.cc index 358c7519aca..7590236203d 100644 --- a/paddle/fluid/eager/tests/data_structure_tests/eager_tensor_test.cc +++ b/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(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(et3.impl())->data(); 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(et4.impl())->data(); 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(et5.impl())->data(); 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 dt = std::make_shared( @@ -97,7 +97,7 @@ TEST(Tensor, MemberFunction) { std::dynamic_pointer_cast(et3.impl())->data(); 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(et5.impl())->data(); 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 dt = std::make_shared( @@ -142,7 +142,7 @@ TEST(EagerVariable, Constructor) { CHECK_EQ(et3.Var().Get().data()[0], 5.0f); CHECK_EQ(et3.Var().Get().data()[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 rows = {1, 2}; std::vector dims = {2}; - paddle::experimental::Tensor t7(std::make_shared(rows, 2)); + paddle::Tensor t7(std::make_shared(rows, 2)); std::dynamic_pointer_cast(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); diff --git a/paddle/fluid/eager/tests/data_structure_tests/grad_node_info_test.cc b/paddle/fluid/eager/tests/data_structure_tests/grad_node_info_test.cc index 63a4a72b631..c56db9e6117 100644 --- a/paddle/fluid/eager/tests/data_structure_tests/grad_node_info_test.cc +++ b/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( /* val */ 5.0, /* in_num */ 2, /* out_num */ 2); auto grad_test_node1 = std::make_shared(); - paddle::small_vector, - egr::kSlotSmallVectorSize> + paddle::small_vector, 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(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 dt = std::make_shared( @@ -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(5, 2, 2); auto auto_grad1 = std::make_shared(); diff --git a/paddle/fluid/eager/tests/data_structure_tests/grad_node_test.h b/paddle/fluid/eager/tests/data_structure_tests/grad_node_test.h index 074e91cd80d..c1125f0774a 100644 --- a/paddle/fluid/eager/tests/data_structure_tests/grad_node_test.h +++ b/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, - egr::kSlotSmallVectorSize> - operator()(paddle::small_vector, + paddle::small_vector, egr::kSlotSmallVectorSize> + operator()(paddle::small_vector, 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(paddle::platform::CPUPlace()); dt_ptr[0] = 6.0f; - paddle::experimental::Tensor et1(dt); - paddle::small_vector, - egr::kSlotSmallVectorSize> + paddle::Tensor et1(dt); + paddle::small_vector, egr::kSlotSmallVectorSize> res = {{et1}}; return res; } diff --git a/paddle/fluid/eager/tests/data_structure_tests/grad_tensor_holder_test.cc b/paddle/fluid/eager/tests/data_structure_tests/grad_tensor_holder_test.cc index 28ce3fee535..b9e5b23a04e 100644 --- a/paddle/fluid/eager/tests/data_structure_tests/grad_tensor_holder_test.cc +++ b/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, - kSlotSmallVectorSize> + paddle::small_vector, kSlotSmallVectorSize> inputs; inputs.push_back({et}); @@ -63,7 +62,7 @@ TEST(GradTensorHolder, Interfaces) { .get(), meta); dt0->mutable_data(paddle::platform::CPUPlace())[0] = 10.0; - paddle::experimental::Tensor et0 = paddle::experimental::Tensor(dt0); + paddle::Tensor et0 = paddle::Tensor(dt0); std::shared_ptr dt1 = std::make_shared( std::make_unique( @@ -71,7 +70,7 @@ TEST(GradTensorHolder, Interfaces) { .get(), meta); dt1->mutable_data(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 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 slot_meta(1); diff --git a/paddle/fluid/eager/tests/data_structure_tests/tensor_wrapper_test.cc b/paddle/fluid/eager/tests/data_structure_tests/tensor_wrapper_test.cc index 8813f364840..86973debfe3 100644 --- a/paddle/fluid/eager/tests/data_structure_tests/tensor_wrapper_test.cc +++ b/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 dt = std::make_shared( @@ -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 dt2 = std::make_shared( @@ -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); } diff --git a/paddle/fluid/eager/tests/performance_tests/benchmark_eager_cpu.cc b/paddle/fluid/eager/tests/performance_tests/benchmark_eager_cpu.cc index 0474f253dec..c8574c527fe 100644 --- a/paddle/fluid/eager/tests/performance_tests/benchmark_eager_cpu.cc +++ b/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 Ws; - std::vector Bs; + std::vector Ws; + std::vector 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)); diff --git a/paddle/fluid/eager/tests/performance_tests/benchmark_eager_cuda.cc b/paddle/fluid/eager/tests/performance_tests/benchmark_eager_cuda.cc index 72dd1cc8ff5..76affa0094a 100644 --- a/paddle/fluid/eager/tests/performance_tests/benchmark_eager_cuda.cc +++ b/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 Ws; - std::vector Bs; + std::vector Ws; + std::vector 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)); diff --git a/paddle/fluid/eager/tests/performance_tests/benchmark_utils.cc b/paddle/fluid/eager/tests/performance_tests/benchmark_utils.cc index 75af7aafe44..c84dd7661b6 100644 --- a/paddle/fluid/eager/tests/performance_tests/benchmark_utils.cc +++ b/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 target_tensors = {input_tensor}; + std::vector 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 target_tensors = {input_tensor0}; + std::vector 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 target_tensors = {input_tensor0}; + std::vector 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& Ws, - const std::vector& Bs, - bool accuracy_check) { - paddle::experimental::Tensor input0 = X; +void benchmark_eager_intermediate_mlp(const paddle::Tensor& X, + const std::vector& Ws, + const std::vector& 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 target_tensors = {Out}; + std::vector target_tensors = {Out}; Backward(target_tensors, {}); if (accuracy_check) { diff --git a/paddle/fluid/eager/tests/performance_tests/benchmark_utils.h b/paddle/fluid/eager/tests/performance_tests/benchmark_utils.h index 5f1d5b90872..82e78013ec2 100644 --- a/paddle/fluid/eager/tests/performance_tests/benchmark_utils.h +++ b/paddle/fluid/eager/tests/performance_tests/benchmark_utils.h @@ -48,23 +48,22 @@ inline std::unordered_map 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& Ws, - const std::vector& Bs, - bool accuracy_check = false); +void benchmark_eager_intermediate_mlp(const paddle::Tensor& X, + const std::vector& Ws, + const std::vector& Bs, + bool accuracy_check = false); } // namespace egr diff --git a/paddle/fluid/eager/tests/task_tests/backward_test.cc b/paddle/fluid/eager/tests/task_tests/backward_test.cc index c91ac93897c..43a994068ca 100644 --- a/paddle/fluid/eager/tests/task_tests/backward_test.cc +++ b/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(1, 1); @@ -77,7 +77,7 @@ TEST(Backward, SingleNodeEmptyGrad) { node0_ptr->SetGradOutMeta({leaf_tensor}, 0); } - std::vector outs = {target_tensor}; + std::vector outs = {target_tensor}; // Run Backward Backward(outs, {}); @@ -90,11 +90,11 @@ TEST(Backward, SingleNodeCustomGrad) { eager_test::InitEnv(paddle::platform::CPUPlace()); // Prepare Inputs - std::vector target_tensors; + std::vector 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 grad_tensors; + std::vector 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(1, 1); @@ -162,11 +162,11 @@ TEST(Backward, LinearNodes) { eager_test::InitEnv(paddle::platform::CPUPlace()); // Prepare Inputs - std::vector target_tensors; + std::vector 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(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 target_tensors; - paddle::experimental::Tensor tensor0 = + std::vector 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 grad_tensors; - paddle::experimental::Tensor grad_tensor0 = + std::vector 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(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); diff --git a/paddle/fluid/eager/tests/task_tests/cross_batch_accumulation_test.cc b/paddle/fluid/eager/tests/task_tests/cross_batch_accumulation_test.cc index 68c78794697..28cc3b2b30b 100644 --- a/paddle/fluid/eager/tests/task_tests/cross_batch_accumulation_test.cc +++ b/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 target_tensors; + std::vector 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(1, 1); scale_node_ptr->SetAttributes_scale(5.0 /*scale*/); diff --git a/paddle/fluid/eager/tests/task_tests/eager_utils_test.cc b/paddle/fluid/eager/tests/task_tests/eager_utils_test.cc index 86b34a6b17d..da0648c3691 100644 --- a/paddle/fluid/eager/tests/task_tests/eager_utils_test.cc +++ b/paddle/fluid/eager/tests/task_tests/eager_utils_test.cc @@ -38,7 +38,7 @@ TEST(EagerUtils, AutoGradMeta) { .get(), meta); dt0->mutable_data(paddle::platform::CPUPlace())[0] = 10.0; - paddle::experimental::Tensor et0 = paddle::experimental::Tensor(dt0); + paddle::Tensor et0 = paddle::Tensor(dt0); std::shared_ptr dt1 = std::make_shared( std::make_unique( @@ -46,7 +46,7 @@ TEST(EagerUtils, AutoGradMeta) { .get(), meta); dt1->mutable_data(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 ets = {et0, et1}; + std::vector ets = {et0, et1}; auto test_node = std::make_shared(); std::vector autograd_metas = EagerUtils::autograd_meta(&ets); @@ -103,11 +103,10 @@ TEST(EagerUtils, AutoGradMeta) { } template -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 dt = std::make_shared( std::make_unique( 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 tensors = { - CreateTestCPUTensor(1.0f, ddim), CreateTestCPUTensor(2.0f, ddim)}; + std::vector tensors = {CreateTestCPUTensor(1.0f, ddim), + CreateTestCPUTensor(2.0f, ddim)}; std::vector> 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, - egr::kSlotSmallVectorSize> - grads = {std::vector(1)}; + paddle::small_vector, egr::kSlotSmallVectorSize> + grads = {std::vector(1)}; paddle::small_vector, egr::kSlotSmallVectorSize> slot_metas = {std::vector(1)}; diff --git a/paddle/fluid/eager/tests/task_tests/forward_autograd_test.cc b/paddle/fluid/eager/tests/task_tests/forward_autograd_test.cc index 79bbde2ad60..b25b40571fb 100644 --- a/paddle/fluid/eager/tests/task_tests/forward_autograd_test.cc +++ b/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 target_tensors; + std::vector 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 target_tensors; + std::vector 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 target_tensors; + std::vector 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 diff --git a/paddle/fluid/eager/tests/task_tests/fwd_bwd_joint_test.cc b/paddle/fluid/eager/tests/task_tests/fwd_bwd_joint_test.cc index 570a78af8f7..5098be17bca 100644 --- a/paddle/fluid/eager/tests/task_tests/fwd_bwd_joint_test.cc +++ b/paddle/fluid/eager/tests/task_tests/fwd_bwd_joint_test.cc @@ -37,8 +37,7 @@ PD_DECLARE_KERNEL(add, KPS, ALL_LAYOUT); namespace egr { -paddle::experimental::Tensor hook_function( - const paddle::experimental::Tensor& t) { +paddle::Tensor hook_function(const paddle::Tensor& t) { auto t_dense = std::dynamic_pointer_cast(t.impl()); auto ret_meta = phi::DenseTensorMeta( @@ -55,7 +54,7 @@ paddle::experimental::Tensor hook_function( } auto ret_impl = std::dynamic_pointer_cast(ret_dense); - paddle::experimental::Tensor ret = paddle::experimental::Tensor(); + paddle::Tensor ret = paddle::Tensor(); ret.set_impl(ret_impl); return ret; @@ -66,7 +65,7 @@ TEST(FwdBwdJoint, SingleNode) { // 1. Prepare Input 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, @@ -78,13 +77,13 @@ TEST(FwdBwdJoint, SingleNode) { // 3. 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 eager_test::CompareTensorWithValue(out, 13.0); - std::vector outs = {out}; + std::vector outs = {out}; // 4. Run Backward Backward(outs, {}); @@ -110,7 +109,7 @@ TEST(FwdBwdJoint, LinearNodes) { // 1. Prepare Input 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, @@ -123,16 +122,16 @@ TEST(FwdBwdJoint, LinearNodes) { // 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 @@ -141,7 +140,7 @@ TEST(FwdBwdJoint, LinearNodes) { // Examine Forward Output 1 eager_test::CompareTensorWithValue(out1, 75.0); - std::vector outs = {out1}; + std::vector outs = {out1}; // 4. Run Backward Backward(outs, {}); @@ -164,7 +163,7 @@ TEST(FwdBwdJoint, BranchedNodes) { // 1. Prepare Input 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, @@ -177,22 +176,22 @@ TEST(FwdBwdJoint, BranchedNodes) { // 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 @@ -215,7 +214,7 @@ TEST(FwdBwdJoint, BranchedNodes) { } // 4. Run Backward - std::vector outs = {out1, out2}; + std::vector outs = {out1, out2}; Backward(outs, {}); // Examine Backward Grad @@ -237,7 +236,7 @@ TEST(FwdBwdJoint, GradientHook) { // 1. Prepare Input 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, @@ -250,11 +249,11 @@ TEST(FwdBwdJoint, GradientHook) { // 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*/); egr_utils_api::RetainGradForTensor(out0); // hook: +5 egr_utils_api::RegisterGradientHookForTensor(out0, hook_function); // hook: +5 @@ -262,7 +261,7 @@ TEST(FwdBwdJoint, GradientHook) { // 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*/); egr_utils_api::RetainGradForTensor(out1); // hook: +5 egr_utils_api::RegisterGradientHookForTensor(out1, @@ -271,14 +270,14 @@ TEST(FwdBwdJoint, GradientHook) { // 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*/); egr_utils_api::RetainGradForTensor(out2); // hook: +5 egr_utils_api::RegisterGradientHookForTensor(out2, hook_function); // hook: +5 // 4. Run Backward - std::vector outs = {out1, out2}; + std::vector outs = {out1, out2}; Backward(outs, {}); // Examine Backward Grad @@ -310,7 +309,7 @@ TEST(FwdBwdJoint, CrossBatchAccumulation) { // 1. Prepare Input 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, @@ -323,26 +322,26 @@ TEST(FwdBwdJoint, CrossBatchAccumulation) { // 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*/); // 4. Run Backward - std::vector outs = {out1, out2}; + std::vector outs = {out1, out2}; Backward(outs, {}); // Examine Backward Grad @@ -365,7 +364,7 @@ TEST(FwdBwdJoint, SingleNodeCUDA) { // 1. Prepare Input 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::CUDAPlace(), phi::DataType::FLOAT32, @@ -377,13 +376,13 @@ TEST(FwdBwdJoint, SingleNodeCUDA) { // 3. 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 eager_test::CompareTensorWithValue(out, 13.0); - std::vector outs = {out}; + std::vector outs = {out}; // 4. Run Backward Backward(outs, {}); @@ -406,7 +405,7 @@ TEST(FwdBwdJoint, BranchedNodesCUDA) { // 1. Prepare Input 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::CUDAPlace(), phi::DataType::FLOAT32, @@ -419,22 +418,22 @@ TEST(FwdBwdJoint, BranchedNodesCUDA) { // 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 @@ -446,7 +445,7 @@ TEST(FwdBwdJoint, BranchedNodesCUDA) { // TODO(jiabin): fix this with add functor // 4. Run Backward - std::vector outs = {out1, out2}; + std::vector outs = {out1, out2}; Backward(outs, {}); // Examine Backward Grad diff --git a/paddle/fluid/eager/tests/task_tests/generated_test.cc b/paddle/fluid/eager/tests/task_tests/generated_test.cc index 45af54f52f7..7b7c47ecb71 100644 --- a/paddle/fluid/eager/tests/task_tests/generated_test.cc +++ b/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(output_tensor, 0.5); - std::vector target_tensors = {output_tensor}; + std::vector 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(output_tensor, 96); - std::vector target_tensors = {output_tensor}; + std::vector target_tensors = {output_tensor}; Backward(target_tensors, {}); eager_test::CompareGradTensorWithValue(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(output_tensor, 5); - std::vector target_tensors = {output_tensor}; + std::vector target_tensors = {output_tensor}; Backward(target_tensors, {}); eager_test::CompareGradTensorWithValue(X, 1.0); diff --git a/paddle/fluid/eager/tests/task_tests/grad_test.cc b/paddle/fluid/eager/tests/task_tests/grad_test.cc index 30c0e92511a..8f76b6d05ee 100644 --- a/paddle/fluid/eager/tests/task_tests/grad_test.cc +++ b/paddle/fluid/eager/tests/task_tests/grad_test.cc @@ -41,7 +41,7 @@ TEST(Grad, SingleNodeEmptyGrad) { paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32}); // Create Target Tensor (output) - paddle::experimental::Tensor output_tensor = + paddle::Tensor output_tensor = egr_utils_api::CreateTensorWithValue(ddim, paddle::platform::CPUPlace(), phi::DataType::FLOAT32, @@ -50,7 +50,7 @@ TEST(Grad, SingleNodeEmptyGrad) { false /*is_leaf*/); // Create input tensor - const paddle::experimental::Tensor leaf_tensor = + const paddle::Tensor leaf_tensor = egr_utils_api::CreateTensorWithValue(ddim, paddle::platform::CPUPlace(), phi::DataType::FLOAT32, @@ -91,7 +91,7 @@ TEST(Grad, SingleNodeEmptyGrad) { std::vector res = {auto_grad_meta1}; node0_ptr->SetGradOutMeta(leaf_tensor, 0); } - std::vector outs = {output_tensor}; + std::vector outs = {output_tensor}; // Run Grad auto result = Grad(outs, {leaf_tensor}, {}); @@ -104,11 +104,11 @@ TEST(Grad, SingleNodeCustomGrad) { eager_test::InitEnv(paddle::platform::CPUPlace()); // Prepare Inputs - std::vector target_tensors; + std::vector 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, @@ -117,9 +117,9 @@ TEST(Grad, SingleNodeCustomGrad) { false /*is_leaf*/); target_tensors.emplace_back(std::move(tensor)); - std::vector grad_tensors; + std::vector 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, @@ -128,7 +128,7 @@ TEST(Grad, SingleNodeCustomGrad) { false /*is_leaf*/); grad_tensors.emplace_back(std::move(grad_tensor)); - paddle::experimental::Tensor leaf_tensor = + paddle::Tensor leaf_tensor = egr_utils_api::CreateTensorWithValue(ddim, paddle::platform::CPUPlace(), phi::DataType::FLOAT32, @@ -183,11 +183,11 @@ TEST(Grad, LinearNodes) { eager_test::InitEnv(paddle::platform::CPUPlace()); // Prepare Target Tensor - std::vector target_tensors; + std::vector 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, @@ -196,7 +196,7 @@ TEST(Grad, LinearNodes) { false /*is_leaf*/); target_tensors.emplace_back(std::move(tensor)); - paddle::experimental::Tensor leaf_tensor = + paddle::Tensor leaf_tensor = egr_utils_api::CreateTensorWithValue(ddim, paddle::platform::CPUPlace(), phi::DataType::FLOAT32, @@ -226,7 +226,7 @@ TEST(Grad, 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); @@ -268,15 +268,15 @@ TEST(Grad, WithAccumulation) { paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32}); // Create Target Tensor - std::vector target_tensors; - paddle::experimental::Tensor tensor0 = + std::vector 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, @@ -287,15 +287,15 @@ TEST(Grad, WithAccumulation) { target_tensors.emplace_back(std::move(tensor1)); // Create Grad Tensor - std::vector grad_tensors; - paddle::experimental::Tensor grad_tensor0 = + std::vector 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, @@ -305,7 +305,7 @@ TEST(Grad, 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(1, 1); @@ -336,7 +336,7 @@ TEST(Grad, 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); @@ -344,7 +344,7 @@ TEST(Grad, 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); diff --git a/paddle/fluid/eager/tests/task_tests/hook_test.cc b/paddle/fluid/eager/tests/task_tests/hook_test.cc index d61e7053fb5..2c67427c55b 100644 --- a/paddle/fluid/eager/tests/task_tests/hook_test.cc +++ b/paddle/fluid/eager/tests/task_tests/hook_test.cc @@ -32,8 +32,7 @@ PD_DECLARE_KERNEL(full, CPU, ALL_LAYOUT); namespace egr { -paddle::experimental::Tensor hook_function( - const paddle::experimental::Tensor& t) { +paddle::Tensor hook_function(const paddle::Tensor& t) { auto t_dense = std::dynamic_pointer_cast(t.impl()); auto ret_meta = phi::DenseTensorMeta( @@ -50,7 +49,7 @@ paddle::experimental::Tensor hook_function( } auto ret_impl = std::dynamic_pointer_cast(ret_dense); - paddle::experimental::Tensor ret = paddle::experimental::Tensor(); + paddle::Tensor ret = paddle::Tensor(); ret.set_impl(ret_impl); return ret; @@ -60,11 +59,11 @@ TEST(RetainGrad, HookBeforeRetainGrad) { eager_test::InitEnv(paddle::platform::CPUPlace()); // Prepare Inputs - std::vector target_tensors; + std::vector 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, @@ -72,7 +71,7 @@ TEST(RetainGrad, HookBeforeRetainGrad) { 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]; // Create ScaleNode auto scale_node_ptr = std::make_shared(1, 1); @@ -92,7 +91,7 @@ TEST(RetainGrad, HookBeforeRetainGrad) { auto_grad_meta->SetSingleOutRankWithSlot(0, 0); auto_grad_meta->SetStopGradient(false); target_tensor.set_autograd_meta( - std::dynamic_pointer_cast( + std::dynamic_pointer_cast( auto_grad_meta)); egr_utils_api::RegisterGradientHookForTensor(target_tensor, hook_function); @@ -103,10 +102,10 @@ TEST(RetainGrad, HookBeforeRetainGrad) { } // Retain Grad for leaf tensor1 - paddle::experimental::Tensor leaf_tensor = paddle::experimental::Tensor(); + paddle::Tensor leaf_tensor = paddle::Tensor(); { // AccumulationNode Hook: +3 - auto tmp_tensor0 = paddle::experimental::Tensor(); + auto tmp_tensor0 = paddle::Tensor(); auto auto_grad_meta = EagerUtils::autograd_meta(&tmp_tensor0); auto acc_node_ptr = std::make_shared(auto_grad_meta); @@ -118,7 +117,7 @@ TEST(RetainGrad, HookBeforeRetainGrad) { scale_node_ptr->SetGradOutMeta(tmp_tensor0, 0); leaf_tensor.set_autograd_meta( - std::dynamic_pointer_cast( + std::dynamic_pointer_cast( tmp_tensor0.mutable_autograd_meta())); egr_utils_api::RegisterGradientHookForTensor(leaf_tensor, hook_function); @@ -136,11 +135,11 @@ TEST(RetainGrad, HookAfterRetainGrad) { eager_test::InitEnv(paddle::platform::CPUPlace()); // Prepare Inputs - std::vector target_tensors; + std::vector 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, @@ -148,7 +147,7 @@ TEST(RetainGrad, HookAfterRetainGrad) { 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]; // Create ScaleNode auto scale_node_ptr = std::make_shared(1, 1); @@ -167,7 +166,7 @@ TEST(RetainGrad, HookAfterRetainGrad) { auto_grad_meta->SetSingleOutRankWithSlot(0, 0); auto_grad_meta->SetStopGradient(false); target_tensor.set_autograd_meta( - std::dynamic_pointer_cast( + std::dynamic_pointer_cast( auto_grad_meta)); egr_utils_api::RetainGradForTensor(target_tensor); // result: 1.0 @@ -175,10 +174,10 @@ TEST(RetainGrad, HookAfterRetainGrad) { } // Retain Grad for leaf tensor1 - paddle::experimental::Tensor leaf_tensor = paddle::experimental::Tensor(); + paddle::Tensor leaf_tensor = paddle::Tensor(); { // AccumulationNode Hook: +3 - auto tmp_tensor0 = paddle::experimental::Tensor(); + auto tmp_tensor0 = paddle::Tensor(); auto auto_grad_meta = EagerUtils::autograd_meta(&tmp_tensor0); auto acc_node_ptr = std::make_shared(auto_grad_meta); auto_grad_meta->SetGradNode(acc_node_ptr); @@ -187,7 +186,7 @@ TEST(RetainGrad, HookAfterRetainGrad) { auto_grad_meta->SetSingleOutRankWithSlot(0, 0); leaf_tensor.set_autograd_meta( - std::dynamic_pointer_cast( + std::dynamic_pointer_cast( tmp_tensor0.mutable_autograd_meta())); egr_utils_api::RegisterGradientHookForTensor(leaf_tensor, hook_function); diff --git a/paddle/fluid/eager/tests/task_tests/hook_test_intermidiate.cc b/paddle/fluid/eager/tests/task_tests/hook_test_intermidiate.cc index 30d22b55620..fe63ff7da48 100644 --- a/paddle/fluid/eager/tests/task_tests/hook_test_intermidiate.cc +++ b/paddle/fluid/eager/tests/task_tests/hook_test_intermidiate.cc @@ -35,8 +35,7 @@ PD_DECLARE_KERNEL(sigmoid_grad, CPU, ALL_LAYOUT); namespace egr { -paddle::experimental::Tensor hook_function( - const paddle::experimental::Tensor& t) { +paddle::Tensor hook_function(const paddle::Tensor& t) { auto t_dense = std::dynamic_pointer_cast(t.impl()); auto ret_meta = phi::DenseTensorMeta( @@ -53,7 +52,7 @@ paddle::experimental::Tensor hook_function( } auto ret_impl = std::dynamic_pointer_cast(ret_dense); - paddle::experimental::Tensor ret = paddle::experimental::Tensor(); + paddle::Tensor ret = paddle::Tensor(); ret.set_impl(ret_impl); return ret; @@ -67,8 +66,8 @@ void test_sigmoid(bool is_remove_gradient_hook) { VLOG(6) << "Make Dim"; paddle::framework::DDim ddim = phi::make_ddim({2, 4, 4, 4}); - VLOG(6) << "Make paddle::experimental::Tensor"; - paddle::experimental::Tensor tensor = + VLOG(6) << "Make paddle::Tensor"; + paddle::Tensor tensor = egr_utils_api::CreateTensorWithValue(ddim, paddle::platform::CPUPlace(), phi::DataType::FLOAT32, @@ -101,7 +100,7 @@ void test_sigmoid(bool is_remove_gradient_hook) { eager_test::CompareTensorWithValue(output_tensor, 0.5); - std::vector target_tensors = {output_tensor}; + std::vector target_tensors = {output_tensor}; if (is_remove_gradient_hook) { std::shared_ptr grad_node_tmp = EagerUtils::grad_node(tensor); @@ -133,7 +132,7 @@ void test_elementwiseAdd(bool is_remove_gradient_hook) { // 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, @@ -143,7 +142,7 @@ void test_elementwiseAdd(bool is_remove_gradient_hook) { 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, @@ -167,7 +166,7 @@ void test_elementwiseAdd(bool is_remove_gradient_hook) { auto output_tensor = elementwise_add_dygraph_function(X, Y, {}); eager_test::CompareTensorWithValue(output_tensor, 5); - std::vector target_tensors = {output_tensor}; + std::vector target_tensors = {output_tensor}; if (is_remove_gradient_hook) { std::shared_ptr grad_node_tmp = EagerUtils::grad_node(Y); @@ -197,7 +196,7 @@ void test_matmul(bool is_remove_gradient_hook) { // 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, @@ -207,7 +206,7 @@ void test_matmul(bool is_remove_gradient_hook) { 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, @@ -232,7 +231,7 @@ void test_matmul(bool is_remove_gradient_hook) { X, Y, {{"trans_x", false}, {"trans_y", false}}); eager_test::CompareTensorWithValue(output_tensor, 96); - std::vector target_tensors = {output_tensor}; + std::vector target_tensors = {output_tensor}; if (is_remove_gradient_hook) { std::shared_ptr grad_node_tmp = EagerUtils::grad_node(Y); @@ -258,9 +257,9 @@ void test_backward_final_hooks() { VLOG(6) << "Init Env"; eager_test::InitEnv(paddle::platform::CPUPlace()); - VLOG(6) << "Make paddle::experimental::Tensor"; + VLOG(6) << "Make paddle::Tensor"; 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, @@ -270,7 +269,7 @@ void test_backward_final_hooks() { paddle::framework::DDim ddimY = phi::make_ddim({16, 20}); egr_utils_api::RetainGradForTensor(X); - paddle::experimental::Tensor Y = + paddle::Tensor Y = egr_utils_api::CreateTensorWithValue(ddimY, paddle::platform::CPUPlace(), phi::DataType::FLOAT32, @@ -298,7 +297,7 @@ void test_backward_final_hooks() { eager_test::CompareTensorWithValue(X, 3.0); - std::vector target_tensors = {output_tensor}; + std::vector target_tensors = {output_tensor}; VLOG(6) << "Runing Backward"; Backward(target_tensors, {}); diff --git a/paddle/fluid/eager/tests/task_tests/nan_inf_utils_test.cc b/paddle/fluid/eager/tests/task_tests/nan_inf_utils_test.cc index 86f863bdffa..49179c9d8e7 100644 --- a/paddle/fluid/eager/tests/task_tests/nan_inf_utils_test.cc +++ b/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 tensor_vec; + std::vector tensor_vec; tensor_vec.emplace_back(tensor); tensor_vec.emplace_back(tensor1); CHECK_NAN_INF(tensor_vec); - paddle::small_vector, - egr::kSlotSmallVectorSize> + paddle::small_vector, 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(); *sr->mutable_value() = *(static_cast(tensor.impl().get())); diff --git a/paddle/fluid/eager/tests/task_tests/tensor_utils_test.cc b/paddle/fluid/eager/tests/task_tests/tensor_utils_test.cc index b964b5908c0..f055839e516 100644 --- a/paddle/fluid/eager/tests/task_tests/tensor_utils_test.cc +++ b/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 target_tensors; + std::vector 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, diff --git a/paddle/fluid/eager/tests/test_utils.h b/paddle/fluid/eager/tests/test_utils.h index 0e62e5c2da6..03539e520ec 100644 --- a/paddle/fluid/eager/tests/test_utils.h +++ b/paddle/fluid/eager/tests/test_utils.h @@ -28,8 +28,7 @@ namespace eager_test { template -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(meta->Grad().impl()); @@ -68,8 +67,7 @@ bool CompareGradTensorWithValue(const paddle::experimental::Tensor& target, } template -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(target.impl()); T* ptr = dense_t->data(); diff --git a/paddle/fluid/eager/to_static/run_program_op_func.h b/paddle/fluid/eager/to_static/run_program_op_func.h index 5ef16474c6c..fad6f7bd31e 100644 --- a/paddle/fluid/eager/to_static/run_program_op_func.h +++ b/paddle/fluid/eager/to_static/run_program_op_func.h @@ -24,11 +24,10 @@ // Filter params without grads in global block. In this case, we will // tag its AutogradMeta with stop_gradient = True to avoid fault from // reducer while training on multi-cards. -static void clear_no_grad_edges( - const std::vector& params, - const paddle::framework::BlockDesc* block_desc, - egr::GradNodeBase* grad_node, - size_t slot_id) { +static void clear_no_grad_edges(const std::vector& params, + const paddle::framework::BlockDesc* block_desc, + egr::GradNodeBase* grad_node, + size_t slot_id) { for (size_t i = 0; i < params.size(); ++i) { auto p_grad_name = paddle::framework::GradVarName(params[i].name()); if (!block_desc->HasVar(p_grad_name)) { @@ -39,7 +38,7 @@ static void clear_no_grad_edges( } static void clear_no_grad_edges_with_partial_block( - const std::vector& params, + const std::vector& params, const paddle::framework::BlockDesc* forward_block_desc, const paddle::framework::BlockDesc* backward_block_desc, egr::GradNodeBase* grad_node, @@ -55,11 +54,11 @@ static void clear_no_grad_edges_with_partial_block( } inline void run_program_ad_func( - const std::vector& x, - const std::vector& params, - std::vector& out, // NOLINT + const std::vector& x, + const std::vector& params, + std::vector& out, // NOLINT std::vector& step_scope, // NOLINT - std::vector& dout, // NOLINT + std::vector& dout, // NOLINT const paddle::framework::AttributeMap& attrs) { VLOG(2) << "start run run_program"; // Call forward function @@ -100,7 +99,7 @@ inline void run_program_ad_func( paddle::framework::BlockDesc*, attrs.at("forward_global_block")); auto* backward_global_block = PADDLE_GET_CONST( paddle::framework::BlockDesc*, attrs.at("backward_global_block")); - std::vector x_require_grad; + std::vector x_require_grad; for (size_t i = 0; i < x.size(); ++i) { auto& name = x[i].name(); if (forward_global_block->HasVar(name) || diff --git a/paddle/fluid/eager/to_static/run_program_op_node.h b/paddle/fluid/eager/to_static/run_program_op_node.h index fd1f5acdf21..d19d671f1ea 100644 --- a/paddle/fluid/eager/to_static/run_program_op_node.h +++ b/paddle/fluid/eager/to_static/run_program_op_node.h @@ -23,7 +23,7 @@ #include "paddle/fluid/platform/profiler/event_tracing.h" namespace details { -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; static std::vector DereferenceTensors( const std::vector &tensor_ptr) { @@ -278,11 +278,11 @@ static void GcScope(paddle::framework::Scope *scope) { } // namespace details inline void RunProgramAPI( - const std::vector &x, - const std::vector ¶ms, - std::vector &out, // NOLINT + const std::vector &x, + const std::vector ¶ms, + std::vector &out, // NOLINT std::vector &step_scope, // NOLINT - std::vector &dout, // NOLINT + std::vector &dout, // NOLINT const paddle::framework::AttributeMap &attrs) { VLOG(2) << "RunProgramOpKernel Compute"; // In the original run_program OP, the default value of the is_test @@ -446,13 +446,13 @@ inline void RunProgramAPI( } inline void RunProgramGradAPI( - const std::vector &x, - const std::vector ¶ms, - const std::vector &out_grad, + const std::vector &x, + const std::vector ¶ms, + const std::vector &out_grad, const std::vector &step_scope, // NOLINT const paddle::framework::AttributeMap &attrs, - std::vector &x_grad, // NOLINT - std::vector ¶ms_grad // NOLINT + std::vector &x_grad, // NOLINT + std::vector ¶ms_grad // NOLINT ) { // if all output vars are set to stop_gradient, grad op no need to executed if (x_grad.empty() && params_grad.empty()) return; @@ -582,15 +582,14 @@ class GradNodeRunProgram : public egr::GradNodeBase { ~GradNodeRunProgram() override = default; // Functor: perform backward computations - virtual paddle::small_vector, + virtual paddle::small_vector, egr::kSlotSmallVectorSize> - operator()(paddle::small_vector, + operator()(paddle::small_vector, egr::kSlotSmallVectorSize> &grads, // NOLINT bool create_graph, bool is_new_grad) override { VLOG(3) << "Running Eager Backward Node: GradNodeRunProgram"; - paddle::small_vector, - egr::kSlotSmallVectorSize> + paddle::small_vector, egr::kSlotSmallVectorSize> hooked_grads = GradNodeRunProgram::ApplyGradientHooks(grads); PADDLE_ENFORCE_EQ(hooked_grads.size(), 1, @@ -598,10 +597,10 @@ class GradNodeRunProgram : public egr::GradNodeBase { "The hooked_grads.size() of RunProgramGradOp should " "be equal to 1.")); - std::vector x_grad; - std::vector params_grad; - std::vector x_grad_ptr; - std::vector params_grad_ptr; + std::vector x_grad; + std::vector params_grad; + std::vector x_grad_ptr; + std::vector params_grad_ptr; { paddle::platform::RecordEvent record_event( "construct_grad_tensor", @@ -651,11 +650,9 @@ class GradNodeRunProgram : public egr::GradNodeBase { attrs_ = attrs; } - void SetFwdX(const std::vector &tensors) { - x_ = tensors; - } + void SetFwdX(const std::vector &tensors) { x_ = tensors; } - void SetFwdParams(const std::vector &tensors) { + void SetFwdParams(const std::vector &tensors) { params_ = tensors; } @@ -664,9 +661,8 @@ class GradNodeRunProgram : public egr::GradNodeBase { } protected: - void ConstructXGradTensors( - const std::vector &x, - std::vector *x_grad) { + void ConstructXGradTensors(const std::vector &x, + std::vector *x_grad) { // TODO(dev): Need an elegant way to determine inforamtion of grad_tensor, // such as: name, tensor type(DenseTensor or SelectedRows). for (auto &t : x) { @@ -679,9 +675,8 @@ class GradNodeRunProgram : public egr::GradNodeBase { } } - void ConstructParamGradTensors( - const std::vector ¶ms, - std::vector *param_grads) { + void ConstructParamGradTensors(const std::vector ¶ms, + std::vector *param_grads) { auto param_grad_names = PADDLE_GET_CONST(std::vector, attrs_.at("param_grad_names")); PADDLE_ENFORCE_EQ(params.size(), @@ -715,8 +710,8 @@ class GradNodeRunProgram : public egr::GradNodeBase { private: // TensorWrappers - std::vector x_; - std::vector params_; + std::vector x_; + std::vector params_; std::vector step_scope_; // Attribute Map diff --git a/paddle/fluid/eager/utils.cc b/paddle/fluid/eager/utils.cc index 4b992f5acaa..3c3506262a5 100644 --- a/paddle/fluid/eager/utils.cc +++ b/paddle/fluid/eager/utils.cc @@ -32,7 +32,7 @@ namespace egr { * Implementation of Eager Utils. **/ -AutogradMeta* EagerUtils::autograd_meta(paddle::experimental::Tensor* target) { +AutogradMeta* EagerUtils::autograd_meta(paddle::Tensor* target) { auto* p_autograd_meta = target->get_autograd_meta(); if (!p_autograd_meta) { auto p_autograd_meta_ptr = std::make_shared(); @@ -42,8 +42,7 @@ AutogradMeta* EagerUtils::autograd_meta(paddle::experimental::Tensor* target) { return static_cast(p_autograd_meta); } -AutogradMeta* EagerUtils::unsafe_autograd_meta( - const paddle::experimental::Tensor& target) { +AutogradMeta* EagerUtils::unsafe_autograd_meta(const paddle::Tensor& target) { auto* p_autograd_meta = target.get_autograd_meta(); PADDLE_ENFORCE(p_autograd_meta, paddle::platform::errors::Fatal( @@ -52,17 +51,16 @@ AutogradMeta* EagerUtils::unsafe_autograd_meta( } std::vector EagerUtils::unsafe_autograd_meta( - const std::vector& targets) { + const std::vector& targets) { std::vector metas; metas.reserve(targets.size()); - for (const paddle::experimental::Tensor& t : targets) { + for (const paddle::Tensor& t : targets) { metas.emplace_back(unsafe_autograd_meta(t)); } return metas; } -AutogradMeta* EagerUtils::nullable_autograd_meta( - const paddle::experimental::Tensor& target) { +AutogradMeta* EagerUtils::nullable_autograd_meta(const paddle::Tensor& target) { auto* p_autograd_meta = target.get_autograd_meta(); if (!p_autograd_meta) return nullptr; @@ -70,7 +68,7 @@ AutogradMeta* EagerUtils::nullable_autograd_meta( } AutogradMeta* EagerUtils::nullable_autograd_meta( - const paddle::optional& target) { + const paddle::optional& target) { if (target.get_ptr() != nullptr) { return EagerUtils::nullable_autograd_meta(*(target.get_ptr())); } @@ -78,27 +76,27 @@ AutogradMeta* EagerUtils::nullable_autograd_meta( } std::vector EagerUtils::nullable_autograd_meta( - const std::vector& targets) { + const std::vector& targets) { std::vector metas; metas.reserve(targets.size()); - for (const paddle::experimental::Tensor& t : targets) { + for (const paddle::Tensor& t : targets) { metas.emplace_back(nullable_autograd_meta(t)); } return metas; } std::vector EagerUtils::nullable_autograd_meta( - const std::vector& targets) { + const std::vector& targets) { std::vector metas; metas.reserve(targets.size()); - for (const paddle::experimental::Tensor* t : targets) { + for (const paddle::Tensor* t : targets) { metas.emplace_back(nullable_autograd_meta(*t)); } return metas; } std::vector EagerUtils::autograd_meta( - std::vector* targets) { + std::vector* targets) { std::vector ret; ret.reserve(targets->size()); @@ -111,7 +109,7 @@ std::vector EagerUtils::autograd_meta( } std::vector EagerUtils::autograd_meta( - std::vector* targets) { + std::vector* targets) { std::vector ret; ret.reserve(targets->size()); @@ -124,12 +122,12 @@ std::vector EagerUtils::autograd_meta( } std::pair EagerUtils::OutRankInfo( - const paddle::experimental::Tensor& target) { + const paddle::Tensor& target) { return unsafe_autograd_meta(target)->OutRankInfo(); } std::shared_ptr EagerUtils::grad_node( - const paddle::experimental::Tensor& target) { + const paddle::Tensor& target) { auto* meta = nullable_autograd_meta(target); if (meta) { return meta->GetMutableGradNode(); @@ -138,8 +136,7 @@ std::shared_ptr EagerUtils::grad_node( } } -paddle::experimental::Tensor* EagerUtils::mutable_grad( - const paddle::experimental::Tensor& target) { +paddle::Tensor* EagerUtils::mutable_grad(const paddle::Tensor& target) { auto* meta = nullable_autograd_meta(target); if (meta) { return meta->MutableGrad(); @@ -182,17 +179,17 @@ void EagerUtils::SetOutRankWithSlot(AutogradMeta* target, size_t slot_id) { } std::shared_ptr EagerUtils::TrySyncToVar( - const paddle::experimental::Tensor& tensor) { + const paddle::Tensor& tensor) { return std::make_shared(tensor); } std::vector> EagerUtils::TrySyncToVars( - const paddle::experimental::Tensor& tensor) { + const paddle::Tensor& tensor) { return {TrySyncToVar(tensor)}; } std::vector> EagerUtils::TrySyncToVars( - paddle::experimental::Tensor* tensor) { + paddle::Tensor* tensor) { PADDLE_ENFORCE_NOT_NULL( tensor, paddle::platform::errors::Fatal( @@ -202,7 +199,7 @@ std::vector> EagerUtils::TrySyncToVars( } std::vector> EagerUtils::TrySyncToVars( - const std::vector& tensors) { + const std::vector& tensors) { std::vector> res; size_t num = tensors.size(); res.reserve(num); @@ -221,7 +218,7 @@ std::vector> EagerUtils::TrySyncToVars( } std::vector> EagerUtils::TrySyncToVars( - const std::vector& tensors) { + const std::vector& tensors) { std::vector> res; size_t num = tensors.size(); res.reserve(num); @@ -272,8 +269,7 @@ void EagerUtils::HandleViewBetweenInputAndOutput( } void EagerUtils::HandleViewBetweenInputAndOutput( - const paddle::experimental::Tensor& input_tensor, - paddle::experimental::Tensor* view_output_tensor) { + const paddle::Tensor& input_tensor, paddle::Tensor* view_output_tensor) { PADDLE_ENFORCE_EQ( input_tensor.initialized(), true, @@ -299,9 +295,9 @@ void EagerUtils::HandleViewBetweenInputAndOutput( } } -std::vector EagerUtils::GetOutputs( +std::vector EagerUtils::GetOutputs( const std::vector>& outs) { - std::vector res; + std::vector res; res.reserve(outs.size()); for (const auto& out : outs) { PADDLE_ENFORCE_NOT_NULL( @@ -317,7 +313,7 @@ std::vector EagerUtils::GetOutputs( return res; } -paddle::experimental::Tensor EagerUtils::GetOutput( +paddle::Tensor EagerUtils::GetOutput( const std::shared_ptr& out) { PADDLE_ENFORCE_NOT_NULL( out.get(), @@ -326,11 +322,11 @@ paddle::experimental::Tensor EagerUtils::GetOutput( "are tring to Get Output tensor from its shared_ptr, " "this error may indicate output is nullptr", out->name())); - return paddle::experimental::Tensor(out->GetTensorBase(), out->name()); + return paddle::Tensor(out->GetTensorBase(), out->name()); } void EagerUtils::GetOutput(const std::shared_ptr& out, - paddle::experimental::Tensor* out_var) { + paddle::Tensor* out_var) { PADDLE_ENFORCE_NOT_NULL( out_var, paddle::platform::errors::Fatal( @@ -344,7 +340,7 @@ void EagerUtils::GetOutput(const std::shared_ptr& out, void EagerUtils::GetOutputs( const std::vector>& outs, - std::vector* result) { + std::vector* result) { for (size_t i = 0; i < outs.size(); i++) { result->emplace_back(outs[i]->GetTensorBase()); } @@ -352,7 +348,7 @@ void EagerUtils::GetOutputs( void EagerUtils::GetOutputs( const std::vector>& outs, - const std::vector& out_var) { + const std::vector& out_var) { for (size_t i = 0; i < outs.size(); i++) { PADDLE_ENFORCE_NOT_NULL( out_var[i], @@ -366,13 +362,12 @@ void EagerUtils::GetOutputs( } void EagerUtils::GetOutputs(const std::shared_ptr& out, - std::vector* result) { + std::vector* result) { result->emplace_back(out->GetTensorBase()); } -void EagerUtils::GetOutputs( - const std::shared_ptr& out, - const std::vector& out_var) { +void EagerUtils::GetOutputs(const std::shared_ptr& out, + const std::vector& out_var) { PADDLE_ENFORCE_NOT_NULL( out_var[0], paddle::platform::errors::Fatal( @@ -383,23 +378,21 @@ void EagerUtils::GetOutputs( out_var[0]->set_impl(out->GetTensorBase()); } -void EagerUtils::Output2Result( - const std::vector& out_var, - std::vector* result) { +void EagerUtils::Output2Result(const std::vector& out_var, + std::vector* result) { result->reserve(out_var.size()); for (size_t i = 0; i < out_var.size(); i++) { result->emplace_back(*out_var[i]); } } -paddle::experimental::Tensor EagerUtils::RecoverTensorWrapper( - TensorWrapper* tw) { +paddle::Tensor EagerUtils::RecoverTensorWrapper(TensorWrapper* tw) { return tw->recover(); } -std::vector EagerUtils::RecoverTensorWrapper( +std::vector EagerUtils::RecoverTensorWrapper( std::vector* tw) { - std::vector ret; + std::vector ret; for (auto& t : *tw) { ret.emplace_back(t.recover()); } @@ -407,7 +400,7 @@ std::vector EagerUtils::RecoverTensorWrapper( } std::shared_ptr EagerUtils::GetGradAccumulationNode( - const paddle::experimental::Tensor& tensor) { + const paddle::Tensor& tensor) { auto* autograd_ptr = nullable_autograd_meta(tensor); if (!autograd_ptr) { return nullptr; @@ -445,10 +438,10 @@ std::shared_ptr EagerUtils::GetGradAccumulationNode( } void EagerUtils::FillZeroForEmptyOptionalGradInput( - std::vector* in_grads, + std::vector* in_grads, const std::vector& grad_in_metas) { for (size_t i = 0; i < in_grads->size(); i++) { - paddle::experimental::Tensor& grad = (*in_grads)[i]; + paddle::Tensor& grad = (*in_grads)[i]; if (!grad.initialized() && grad_in_metas[i].HasTensorMeta()) { auto tensor_with_zero = paddle::experimental::full( phi::vectorize(grad_in_metas[i].GetTensorMeta().dims), @@ -460,8 +453,8 @@ void EagerUtils::FillZeroForEmptyOptionalGradInput( } } -void EagerUtils::FillZeroForEmptyGradInput( - paddle::experimental::Tensor* in_grad, const GradSlotMeta& grad_in_meta) { +void EagerUtils::FillZeroForEmptyGradInput(paddle::Tensor* in_grad, + const GradSlotMeta& grad_in_meta) { if (!in_grad->initialized()) { PADDLE_ENFORCE( grad_in_meta.HasTensorMeta(), @@ -478,7 +471,7 @@ void EagerUtils::FillZeroForEmptyGradInput( } void EagerUtils::FillZeroForEmptyOptionalGradInput( - paddle::experimental::Tensor* in_grad, const GradSlotMeta& grad_in_meta) { + paddle::Tensor* in_grad, const GradSlotMeta& grad_in_meta) { if (!in_grad->initialized() && grad_in_meta.HasTensorMeta()) { const auto& tensor_meta = grad_in_meta.GetTensorMeta(); auto tensor_with_zero = @@ -491,7 +484,7 @@ void EagerUtils::FillZeroForEmptyOptionalGradInput( } void EagerUtils::FillZeroForEmptyGradInput( - std::vector* in_grads, + std::vector* in_grads, const std::vector& grad_in_metas) { for (size_t i = 0; i < in_grads->size(); i++) { FillZeroForEmptyGradInput(&in_grads->at(i), grad_in_metas[i]); diff --git a/paddle/fluid/eager/utils.h b/paddle/fluid/eager/utils.h index a726528f53d..bf720fb5b9a 100644 --- a/paddle/fluid/eager/utils.h +++ b/paddle/fluid/eager/utils.h @@ -92,21 +92,18 @@ class EagerUtils { * constructor (it's abstract class there) * * **/ - static AutogradMeta* autograd_meta(paddle::experimental::Tensor* target); + static AutogradMeta* autograd_meta(paddle::Tensor* target); static std::vector autograd_meta( - std::vector* targets); + std::vector* targets); static std::vector autograd_meta( - std::vector* targets); + std::vector* targets); - static std::pair OutRankInfo( - const paddle::experimental::Tensor& target); + static std::pair OutRankInfo(const paddle::Tensor& target); - static std::shared_ptr grad_node( - const paddle::experimental::Tensor& target); - static paddle::experimental::Tensor* mutable_grad( - const paddle::experimental::Tensor& target); + static std::shared_ptr grad_node(const paddle::Tensor& target); + static paddle::Tensor* mutable_grad(const paddle::Tensor& target); // Set history is used to set backward info during forward process, it will // set forward var's autograd meta's grad node as current backward node. @@ -121,18 +118,16 @@ class EagerUtils { static void SetOutRankWithSlot(AutogradMeta* target, size_t slot_id); // This method will return an AutogradMeta pointer unsafely. + static AutogradMeta* nullable_autograd_meta(const paddle::Tensor& target); static AutogradMeta* nullable_autograd_meta( - const paddle::experimental::Tensor& target); - static AutogradMeta* nullable_autograd_meta( - const paddle::optional& target); + const paddle::optional& target); static std::vector nullable_autograd_meta( - const std::vector& targets); + const std::vector& targets); static std::vector nullable_autograd_meta( - const std::vector& targets); - static AutogradMeta* unsafe_autograd_meta( - const paddle::experimental::Tensor& target); + const std::vector& targets); + static AutogradMeta* unsafe_autograd_meta(const paddle::Tensor& target); static std::vector unsafe_autograd_meta( - const std::vector& targets); + const std::vector& targets); template static bool ComputeRequireGrad(T trace_backward, Args&&... args) { @@ -154,7 +149,7 @@ class EagerUtils { iter.apply(std::forward(args)...); } - static void CheckInplace(const paddle::experimental::Tensor& target, + static void CheckInplace(const paddle::Tensor& target, const AutogradMeta* autograd_meta, bool require_any_grad) { if (require_any_grad && autograd_meta) { @@ -173,76 +168,72 @@ class EagerUtils { const std::shared_ptr& input_var, const std::shared_ptr& view_output_var); static void HandleViewBetweenInputAndOutput( - const paddle::experimental::Tensor& input_tensor, - paddle::experimental::Tensor* view_output_tensor); + const paddle::Tensor& input_tensor, paddle::Tensor* view_output_tensor); // TensorWrapper Utils - static paddle::experimental::Tensor RecoverTensorWrapper(TensorWrapper* tw); - static std::vector RecoverTensorWrapper( + static paddle::Tensor RecoverTensorWrapper(TensorWrapper* tw); + static std::vector RecoverTensorWrapper( std::vector* tw); // Intermidate needed remove this once we don't need legacy // Inner Method static std::shared_ptr TrySyncToVar( - const paddle::experimental::Tensor& tensor); + const paddle::Tensor& tensor); // Basic Input static std::vector> TrySyncToVars( - const paddle::experimental::Tensor& tensor); + const paddle::Tensor& tensor); // Basic Output static std::vector> TrySyncToVars( - paddle::experimental::Tensor* tensor); + paddle::Tensor* tensor); // Multi Output static std::vector> TrySyncToVars( - const std::vector& tensors); + const std::vector& tensors); // Multi Input static std::vector> TrySyncToVars( - const std::vector& tensors); + const std::vector& tensors); // Construct empty output static std::vector> CreateVars( const size_t num); // Construct Tensor From var - static std::vector GetOutputs( + static std::vector GetOutputs( const std::vector>& outs); - static paddle::experimental::Tensor GetOutput( - const std::shared_ptr& out); + static paddle::Tensor GetOutput(const std::shared_ptr& out); static void GetOutput(const std::shared_ptr& out, - paddle::experimental::Tensor* out_var); + paddle::Tensor* out_var); static void GetOutputs( const std::vector>& outs, - std::vector* result); + std::vector* result); static void GetOutputs( const std::vector>& outs, - const std::vector& out_var); + const std::vector& out_var); static void GetOutputs(const std::shared_ptr& out, - std::vector* result); - static void GetOutputs( - const std::shared_ptr& out, - const std::vector& out_var); + std::vector* result); + static void GetOutputs(const std::shared_ptr& out, + const std::vector& out_var); - static void Output2Result( - const std::vector& out_var, - std::vector* result); + static void Output2Result(const std::vector& out_var, + std::vector* result); static std::shared_ptr GetGradAccumulationNode( - const paddle::experimental::Tensor& tensor); + const paddle::Tensor& tensor); /** * Fill Zero * **/ static void FillZeroForEmptyOptionalGradInput( - std::vector* in_grads, + std::vector* in_grads, const std::vector& grad_in_metas); - static void FillZeroForEmptyGradInput(paddle::experimental::Tensor* in_grad, + static void FillZeroForEmptyGradInput(paddle::Tensor* in_grad, const GradSlotMeta& grad_in_meta); static void FillZeroForEmptyOptionalGradInput( - paddle::experimental::Tensor* in_grad, const GradSlotMeta& grad_in_meta); + paddle::Tensor* in_grad, const GradSlotMeta& grad_in_meta); static void FillZeroForEmptyGradInput( - std::vector* in_grads, + std::vector* in_grads, const std::vector& grad_in_metas); /** * Print Input Output (level 0 means least info, level 2 means most info) * **/ - static const std::string TensorStr(const paddle::experimental::Tensor& t) { + static const std::string TensorStr(const paddle::Tensor& t) { std::string tensor_name_str = ""; if (t.name() == "") { tensor_name_str = "None"; @@ -430,7 +421,7 @@ class EagerUtils { } } - static const std::string GradNodeStr(const paddle::experimental::Tensor& t) { + static const std::string GradNodeStr(const paddle::Tensor& t) { auto* ad_meta = nullable_autograd_meta(t); if (ad_meta && (ad_meta->GetMutableGradNode().get())) { return GradNodeStr((*ad_meta->GetMutableGradNode().get())); @@ -440,7 +431,7 @@ class EagerUtils { } static const std::string TensorStr( - const std::vector& tensors) { + const std::vector& tensors) { std::string tensors_str = ""; for (const auto& tensor : tensors) { tensors_str += TensorStr(tensor) + ", "; @@ -449,7 +440,7 @@ class EagerUtils { } static const std::string TensorStr( - const paddle::optional& t) { + const paddle::optional& t) { if (!t.is_initialized()) { return "{ UnDefinedTensor }"; } else { @@ -458,8 +449,7 @@ class EagerUtils { } static const std::string TensorStr( - const paddle::optional>& - tensors) { + const paddle::optional>& tensors) { std::string tensors_str = ""; if (!tensors.is_initialized()) { return "[ UnDefinedTensor List ]"; diff --git a/paddle/fluid/framework/custom_operator.cc b/paddle/fluid/framework/custom_operator.cc index fb409cffb1d..9a834e58323 100644 --- a/paddle/fluid/framework/custom_operator.cc +++ b/paddle/fluid/framework/custom_operator.cc @@ -147,7 +147,7 @@ static void RunKernelFunc(const framework::ExecutionContext& ctx, true, platform::errors::NotFound( "Input vector (%s) is empty.", in_name)); - std::vector custom_vec_in; + std::vector custom_vec_in; for (size_t i = 0; i < vec_x.size(); ++i) { auto* x = vec_x[i]; PADDLE_ENFORCE_NOT_NULL( @@ -163,7 +163,7 @@ static void RunKernelFunc(const framework::ExecutionContext& ctx, "is not initialized.", i, in_name)); - paddle::experimental::Tensor custom_t; + paddle::Tensor custom_t; custom_t.set_impl(std::make_shared(*x)); custom_vec_in.emplace_back(custom_t); } @@ -177,7 +177,7 @@ static void RunKernelFunc(const framework::ExecutionContext& ctx, true, platform::errors::InvalidArgument( "Input tensor (%s) is not initialized.", in_name)); - paddle::experimental::Tensor custom_in; + paddle::Tensor custom_in; custom_in.set_impl(std::make_shared(*x)); #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP) if (custom_in.is_gpu_pinned()) { @@ -244,7 +244,7 @@ static void RunKernelFunc(const framework::ExecutionContext& ctx, true, platform::errors::NotFound( "Output vector (%s) is empty.", out_name)); - std::vector custom_vec_out; + std::vector custom_vec_out; for (size_t j = 0; j < vec_out.size(); ++j) { auto* out = vec_out[j]; PADDLE_ENFORCE_NOT_NULL( @@ -254,7 +254,7 @@ static void RunKernelFunc(const framework::ExecutionContext& ctx, j, out_name)); true_out_ptrs.emplace_back(out); - paddle::experimental::Tensor custom_t; + paddle::Tensor custom_t; // here only can copy the output tensor into context custom_t.set_impl(std::make_shared(*out)); custom_vec_out.emplace_back(custom_t); @@ -266,7 +266,7 @@ static void RunKernelFunc(const framework::ExecutionContext& ctx, platform::errors::NotFound( "Output tensor (%s) is nullptr.", out_name)); true_out_ptrs.emplace_back(out); - paddle::experimental::Tensor custom_out; + paddle::Tensor custom_out; // here only can copy the output tensor into context custom_out.set_impl(std::make_shared(*out)); kernel_ctx.EmplaceBackOutput(std::move(custom_out)); diff --git a/paddle/fluid/imperative/gradient_accumulator.cc b/paddle/fluid/imperative/gradient_accumulator.cc index c1838ee201d..07187ce5b82 100644 --- a/paddle/fluid/imperative/gradient_accumulator.cc +++ b/paddle/fluid/imperative/gradient_accumulator.cc @@ -127,7 +127,7 @@ TType* GetInnerMutableTensor(framework::Variable* dst) { } template -TType* GetInnerMutableTensor(paddle::experimental::Tensor* dst) { +TType* GetInnerMutableTensor(paddle::Tensor* dst) { auto* dst_tensor = static_cast(dst->impl().get()); return dst_tensor; } @@ -138,7 +138,7 @@ const TType& GetInnerTensor(const framework::Variable& src) { } template -TType& GetInnerTensor(const paddle::experimental::Tensor& src) { +TType& GetInnerTensor(const paddle::Tensor& src) { PADDLE_ENFORCE_EQ( src.initialized(), true, @@ -150,7 +150,7 @@ TType& GetInnerTensor(const paddle::experimental::Tensor& src) { } template -TType* GetEmptyInnerTensor(paddle::experimental::Tensor* dst) { +TType* GetEmptyInnerTensor(paddle::Tensor* dst) { PADDLE_ENFORCE_EQ( dst->defined(), false, @@ -361,8 +361,8 @@ void TensorAdd(const VarType& src, VarType* dst) { template void TensorAdd(const framework::Variable& src, framework::Variable* dst); -template void TensorAdd( - const paddle::experimental::Tensor& src, paddle::experimental::Tensor* dst); +template void TensorAdd(const paddle::Tensor& src, + paddle::Tensor* dst); template void SelectedRowsAddToTensor(const VarType& src, VarType* dst) { @@ -405,8 +405,8 @@ void SelectedRowsAddToTensor(const VarType& src, VarType* dst) { template void SelectedRowsAddToTensor(const framework::Variable& src, framework::Variable* dst); -template void SelectedRowsAddToTensor(const paddle::experimental::Tensor& src, - paddle::experimental::Tensor* dst); +template void SelectedRowsAddToTensor(const paddle::Tensor& src, + paddle::Tensor* dst); template void SelectedRowsAddTensor(const VarType& src_selected_rows_var, @@ -458,10 +458,9 @@ template void SelectedRowsAddTensor( const framework::Variable& src_selected_rows_var, const framework::Variable& src_tensor_var, framework::Variable* dst_tensor_var); -template void SelectedRowsAddTensor( - const paddle::experimental::Tensor& src_selected_rows_var, - const paddle::experimental::Tensor& src_tensor_var, - paddle::experimental::Tensor* dst_tensor_var); +template void SelectedRowsAddTensor(const paddle::Tensor& src_selected_rows_var, + const paddle::Tensor& src_tensor_var, + paddle::Tensor* dst_tensor_var); // Note(chenweihang): when two selected rows need to be added, // adding one to another is not equal to merging two selected rows @@ -523,9 +522,8 @@ std::shared_ptr SelectedRowsMerge(const VarType& src1, framework::DataTypeToString(data_type))); } -template std::shared_ptr SelectedRowsMerge( - const paddle::experimental::Tensor& src1, - const paddle::experimental::Tensor& src2); +template std::shared_ptr SelectedRowsMerge( + const paddle::Tensor& src1, const paddle::Tensor& src2); template std::shared_ptr SelectedRowsMerge( const framework::Variable& src1, const framework::Variable& src2); diff --git a/paddle/fluid/imperative/tests/test_gradient_accmulator.cc b/paddle/fluid/imperative/tests/test_gradient_accmulator.cc index 6768a0ef35a..36e10b393f8 100644 --- a/paddle/fluid/imperative/tests/test_gradient_accmulator.cc +++ b/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(t1, - t2); + paddle::imperative::SelectedRowsMerge(t1, t2); auto* new_buffer_tensor = static_cast(new_buffer->impl().get()); auto* new_buffer_data_sr1 = diff --git a/paddle/fluid/jit/engine/base_engine.h b/paddle/fluid/jit/engine/base_engine.h index b6571d7ebdd..a4e4740c23b 100644 --- a/paddle/fluid/jit/engine/base_engine.h +++ b/paddle/fluid/jit/engine/base_engine.h @@ -19,7 +19,7 @@ namespace paddle { namespace jit { -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; using DenseTensor = phi::DenseTensor; class BaseEngine { diff --git a/paddle/fluid/jit/function.h b/paddle/fluid/jit/function.h index a80d46d6399..0c500a535ae 100644 --- a/paddle/fluid/jit/function.h +++ b/paddle/fluid/jit/function.h @@ -23,7 +23,7 @@ namespace paddle { namespace jit { class BaseEngine; using DenseTensor = phi::DenseTensor; -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; class Function { public: diff --git a/paddle/fluid/jit/function_utils.h b/paddle/fluid/jit/function_utils.h index 5daa5ada200..cc218388ed4 100644 --- a/paddle/fluid/jit/function_utils.h +++ b/paddle/fluid/jit/function_utils.h @@ -35,7 +35,7 @@ namespace jit { using Variable = paddle::framework::Variable; using VariableMap = std::unordered_map>; using DenseTensor = phi::DenseTensor; -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; namespace utils { diff --git a/paddle/fluid/jit/layer.h b/paddle/fluid/jit/layer.h index 4f76a41d06f..599237463cb 100644 --- a/paddle/fluid/jit/layer.h +++ b/paddle/fluid/jit/layer.h @@ -35,7 +35,7 @@ class CompilationUnit; class FunctionInfo; using DenseTensor = phi::DenseTensor; -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; using Variable = paddle::framework::Variable; using VariableMap = std::unordered_map>; using FunctionInfoMap = diff --git a/paddle/fluid/operators/cast_op.cc b/paddle/fluid/operators/cast_op.cc index 4f055bd41a1..3f743e5a0e4 100644 --- a/paddle/fluid/operators/cast_op.cc +++ b/paddle/fluid/operators/cast_op.cc @@ -73,9 +73,9 @@ class CastCompositeGradOpMaker : public prim::CompositeGradOpMakerBase { using prim::CompositeGradOpMakerBase::CompositeGradOpMakerBase; void Apply() override { - paddle::experimental::Tensor out_grad = paddle::experimental::Tensor( + paddle::Tensor out_grad = paddle::Tensor( std::make_shared(this->SingleOutputGrad("Out"))); - paddle::experimental::Tensor x_grad = paddle::experimental::Tensor( + paddle::Tensor x_grad = paddle::Tensor( std::make_shared(this->SingleInputGrad("X"))); auto dx_ptr = this->GetOutputPtr(&x_grad); std::string dx_name = this->GetOutputName(x_grad); diff --git a/paddle/fluid/operators/concat_op.cc b/paddle/fluid/operators/concat_op.cc index 869eae74a18..979e7a529b7 100644 --- a/paddle/fluid/operators/concat_op.cc +++ b/paddle/fluid/operators/concat_op.cc @@ -161,22 +161,18 @@ class ConcatCompositeGradOpMaker : public prim::CompositeGradOpMakerBase { public: void Apply() override { - std::vector input = - this->GetMultiForwardInput("X"); - paddle::optional tensor_axis = + std::vector input = this->GetMultiForwardInput("X"); + paddle::optional tensor_axis = this->GetOptionalSingleForwardInput("AxisTensor"); - paddle::experimental::Tensor out_grad = this->GetSingleOutputGrad("Out"); - std::vector input_grad = - this->GetMultiForwardInput("X"); + paddle::Tensor out_grad = this->GetSingleOutputGrad("Out"); + std::vector input_grad = this->GetMultiForwardInput("X"); - std::vector input_grad_ptr( - input_grad.size()); + std::vector input_grad_ptr(input_grad.size()); for (auto sub_tensor : input_grad) { input_grad_ptr.push_back(&sub_tensor); } int axis = static_cast(this->Attr("axis")); - std::vector dx_ptr = - this->GetOutputPtr(input_grad_ptr); + std::vector dx_ptr = this->GetOutputPtr(input_grad_ptr); std::vector dx_name = this->GetOutputName(input_grad); VLOG(6) << "Runing concat_grad composite func"; diff --git a/paddle/fluid/operators/cum_op.cc b/paddle/fluid/operators/cum_op.cc index 7e001d18681..2c42280c6d4 100644 --- a/paddle/fluid/operators/cum_op.cc +++ b/paddle/fluid/operators/cum_op.cc @@ -108,9 +108,9 @@ class CumsumCompositeGradOpMaker : public prim::CompositeGradOpMakerBase { public: void Apply() override { - paddle::experimental::Tensor x = this->GetSingleForwardInput("X"); - paddle::experimental::Tensor out_grad = this->GetSingleOutputGrad("Out"); - paddle::experimental::Tensor dx = this->GetSingleInputGrad("X"); + paddle::Tensor x = this->GetSingleForwardInput("X"); + paddle::Tensor out_grad = this->GetSingleOutputGrad("Out"); + paddle::Tensor dx = this->GetSingleInputGrad("X"); auto* dx_ptr = this->GetOutputPtr(&dx); std::string dx_name = this->GetOutputName(dx); int axis = static_cast(this->Attr("axis")); diff --git a/paddle/fluid/operators/elementwise/elementwise_add_op.cc b/paddle/fluid/operators/elementwise/elementwise_add_op.cc index 5b81438aaf1..872977b6161 100644 --- a/paddle/fluid/operators/elementwise/elementwise_add_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_add_op.cc @@ -57,13 +57,13 @@ class ElementwiseAddCompositeGradOpMaker public: void Apply() override { - paddle::experimental::Tensor x = this->GetSingleForwardInput("X"); - paddle::experimental::Tensor y = this->GetSingleForwardInput("Y"); - paddle::experimental::Tensor out_grad = this->GetSingleOutputGrad("Out"); - paddle::experimental::Tensor dx = this->GetSingleInputGrad("X"); + paddle::Tensor x = this->GetSingleForwardInput("X"); + paddle::Tensor y = this->GetSingleForwardInput("Y"); + paddle::Tensor out_grad = this->GetSingleOutputGrad("Out"); + paddle::Tensor dx = this->GetSingleInputGrad("X"); auto* dx_ptr = this->GetOutputPtr(&dx); std::string dx_name = this->GetOutputName(dx); - paddle::experimental::Tensor dy = this->GetSingleInputGrad("Y"); + paddle::Tensor dy = this->GetSingleInputGrad("Y"); auto* dy_ptr = this->GetOutputPtr(&dy); std::string dy_name = this->GetOutputName(dy); int axis = static_cast(this->Attr("axis")); diff --git a/paddle/fluid/operators/elementwise/elementwise_div_op.cc b/paddle/fluid/operators/elementwise/elementwise_div_op.cc index 7012f3f671e..88856658d31 100644 --- a/paddle/fluid/operators/elementwise/elementwise_div_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_div_op.cc @@ -73,14 +73,14 @@ class ElementwiseDivCompositeGradOpMaker public: void Apply() override { - paddle::experimental::Tensor x = this->GetSingleForwardInput("X"); - paddle::experimental::Tensor y = this->GetSingleForwardInput("Y"); - paddle::experimental::Tensor out = this->GetSingleForwardOutput("Out"); - paddle::experimental::Tensor out_grad = this->GetSingleOutputGrad("Out"); - paddle::experimental::Tensor dx = this->GetSingleInputGrad("X"); + paddle::Tensor x = this->GetSingleForwardInput("X"); + paddle::Tensor y = this->GetSingleForwardInput("Y"); + paddle::Tensor out = this->GetSingleForwardOutput("Out"); + paddle::Tensor out_grad = this->GetSingleOutputGrad("Out"); + paddle::Tensor dx = this->GetSingleInputGrad("X"); auto dx_ptr = this->GetOutputPtr(&dx); std::string dx_name = this->GetOutputName(dx); - paddle::experimental::Tensor dy = this->GetSingleInputGrad("Y"); + paddle::Tensor dy = this->GetSingleInputGrad("Y"); auto dy_ptr = this->GetOutputPtr(&dy); std::string dy_name = this->GetOutputName(dy); int axis = static_cast(this->Attr("axis")); diff --git a/paddle/fluid/operators/elementwise/elementwise_sub_op.cc b/paddle/fluid/operators/elementwise/elementwise_sub_op.cc index 6088ac3d019..f1df6442006 100644 --- a/paddle/fluid/operators/elementwise/elementwise_sub_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_sub_op.cc @@ -60,13 +60,13 @@ class ElementwiseSubCompositeGradOpMaker public: void Apply() override { - paddle::experimental::Tensor x = this->GetSingleForwardInput("X"); - paddle::experimental::Tensor y = this->GetSingleForwardInput("Y"); - paddle::experimental::Tensor out_grad = this->GetSingleOutputGrad("Out"); - paddle::experimental::Tensor dx = this->GetSingleInputGrad("X"); + paddle::Tensor x = this->GetSingleForwardInput("X"); + paddle::Tensor y = this->GetSingleForwardInput("Y"); + paddle::Tensor out_grad = this->GetSingleOutputGrad("Out"); + paddle::Tensor dx = this->GetSingleInputGrad("X"); auto dx_ptr = this->GetOutputPtr(&dx); std::string dx_name = this->GetOutputName(dx); - paddle::experimental::Tensor dy = this->GetSingleInputGrad("Y"); + paddle::Tensor dy = this->GetSingleInputGrad("Y"); auto dy_ptr = this->GetOutputPtr(&dy); std::string dy_name = this->GetOutputName(dy); int axis = static_cast(this->Attr("axis")); diff --git a/paddle/fluid/operators/gather_op.cc b/paddle/fluid/operators/gather_op.cc index de0c6409b46..d876d078541 100644 --- a/paddle/fluid/operators/gather_op.cc +++ b/paddle/fluid/operators/gather_op.cc @@ -140,12 +140,12 @@ class GatherCompositeGradOpMaker : public prim::CompositeGradOpMakerBase { protected: void Apply() override { - paddle::experimental::Tensor index = this->GetSingleForwardInput("Index"); - paddle::optional tensor_axis = + paddle::Tensor index = this->GetSingleForwardInput("Index"); + paddle::optional tensor_axis = this->GetOptionalSingleForwardInput("Axis"); - paddle::experimental::Tensor x = this->GetSingleForwardInput("X"); - paddle::experimental::Tensor dout = this->GetSingleOutputGrad("Out"); - paddle::experimental::Tensor dx = this->GetSingleInputGrad("X"); + paddle::Tensor x = this->GetSingleForwardInput("X"); + paddle::Tensor dout = this->GetSingleOutputGrad("Out"); + paddle::Tensor dx = this->GetSingleInputGrad("X"); auto* dx_ptr = this->GetOutputPtr(&dx); std::string dx_name = this->GetOutputName(*dx_ptr); int axis = static_cast(this->Attr("axis")); diff --git a/paddle/fluid/operators/generator/templates/operator_utils.c.j2 b/paddle/fluid/operators/generator/templates/operator_utils.c.j2 index 5f0147f61d1..eac7abee64f 100644 --- a/paddle/fluid/operators/generator/templates/operator_utils.c.j2 +++ b/paddle/fluid/operators/generator/templates/operator_utils.c.j2 @@ -722,7 +722,7 @@ class {{op_name | to_composite_grad_opmaker_name}} : public prim::CompositeGradO {% if output_typename == "Tensor" %} auto {{outputs[i]}} = this->GetOutputPtr(&{{outputs[i]+ "_t"}}); {% elif output_typename == "Tensor[]" %} - std::vector {{outputs[i]}}({{outputs[i] + "_t"}}.size()); + std::vector {{outputs[i]}}({{outputs[i] + "_t"}}.size()); for(size_t i = 0; i < {{outputs[i]}}.size(); ++i){ {{outputs[i]}}[i] = &{{outputs[i] + "_t"}}[i]; } diff --git a/paddle/fluid/operators/matmul_v2_op.cc b/paddle/fluid/operators/matmul_v2_op.cc index 785cf80433b..4d46a87ccef 100644 --- a/paddle/fluid/operators/matmul_v2_op.cc +++ b/paddle/fluid/operators/matmul_v2_op.cc @@ -253,13 +253,13 @@ class MatMulCompositeDoubleGradOpMaker : public prim::CompositeGradOpMakerBase { using prim::CompositeGradOpMakerBase::CompositeGradOpMakerBase; void Apply() override { // get inputs - paddle::experimental::Tensor x = this->GetSingleForwardInput("X"); - paddle::experimental::Tensor y = this->GetSingleForwardInput("Y"); - paddle::experimental::Tensor dout = + paddle::Tensor x = this->GetSingleForwardInput("X"); + paddle::Tensor y = this->GetSingleForwardInput("Y"); + paddle::Tensor dout = this->GetSingleForwardInput(framework::GradVarName("Out")); - paddle::optional ddx = + paddle::optional ddx = this->GetOptionalSingleOutputGrad(framework::GradVarName("X")); - paddle::optional ddy = + paddle::optional ddy = this->GetOptionalSingleOutputGrad(framework::GradVarName("Y")); // get attr @@ -267,16 +267,15 @@ class MatMulCompositeDoubleGradOpMaker : public prim::CompositeGradOpMakerBase { bool trans_y = this->Attr("trans_y"); // get output - paddle::experimental::Tensor x_grad_t = this->GetSingleInputGrad("X"); - paddle::experimental::Tensor y_grad_t = this->GetSingleInputGrad("Y"); - paddle::experimental::Tensor grad_out_grad_t = + paddle::Tensor x_grad_t = this->GetSingleInputGrad("X"); + paddle::Tensor y_grad_t = this->GetSingleInputGrad("Y"); + paddle::Tensor grad_out_grad_t = this->GetSingleInputGrad(framework::GradVarName("Out")); // get output ptr - paddle::experimental::Tensor* x_grad = this->GetOutputPtr(&x_grad_t); - paddle::experimental::Tensor* y_grad = this->GetOutputPtr(&y_grad_t); - paddle::experimental::Tensor* grad_out_grad = - this->GetOutputPtr(&grad_out_grad_t); + paddle::Tensor* x_grad = this->GetOutputPtr(&x_grad_t); + paddle::Tensor* y_grad = this->GetOutputPtr(&y_grad_t); + paddle::Tensor* grad_out_grad = this->GetOutputPtr(&grad_out_grad_t); // get output orginal name std::string x_grad_name = this->GetOutputName(x_grad_t); std::string y_grad_name = this->GetOutputName(y_grad_t); diff --git a/paddle/fluid/operators/reduce_ops/reduce_sum_op.cc b/paddle/fluid/operators/reduce_ops/reduce_sum_op.cc index 5d14a0911fb..7098432c80e 100644 --- a/paddle/fluid/operators/reduce_ops/reduce_sum_op.cc +++ b/paddle/fluid/operators/reduce_ops/reduce_sum_op.cc @@ -69,18 +69,18 @@ class ReduceSumCompositeGradOpMaker : public prim::CompositeGradOpMakerBase { using prim::CompositeGradOpMakerBase::CompositeGradOpMakerBase; void Apply() override { // get inputs - paddle::experimental::Tensor x = this->GetSingleForwardInput("X"); - paddle::experimental::Tensor out_grad = this->GetSingleOutputGrad("Out"); + paddle::Tensor x = this->GetSingleForwardInput("X"); + paddle::Tensor out_grad = this->GetSingleOutputGrad("Out"); // get attr std::vector axis = this->Attr>("dim"); bool keep_dim = this->Attr("keep_dim"); bool reduce_all = this->Attr("reduce_all"); // get output - paddle::experimental::Tensor x_grad_t = this->GetSingleInputGrad("X"); + paddle::Tensor x_grad_t = this->GetSingleInputGrad("X"); // get output ptr - paddle::experimental::Tensor* x_grad = this->GetOutputPtr(&x_grad_t); + paddle::Tensor* x_grad = this->GetOutputPtr(&x_grad_t); // get output orginal name std::string x_grad_name = this->GetOutputName(x_grad_t); diff --git a/paddle/fluid/operators/reshape_op.cc b/paddle/fluid/operators/reshape_op.cc index ae144135836..2a28ceaa18a 100644 --- a/paddle/fluid/operators/reshape_op.cc +++ b/paddle/fluid/operators/reshape_op.cc @@ -580,9 +580,9 @@ class Reshape2CompositeGradOpMaker : public prim::CompositeGradOpMakerBase { void Apply() override { // We prefer to use x.shape instead of using xshape, this is different from // PHI definition. - paddle::experimental::Tensor x = this->GetSingleForwardInput("X"); - paddle::experimental::Tensor out_grad = this->GetSingleOutputGrad("Out"); - paddle::experimental::Tensor dx = this->GetSingleInputGrad("X"); + paddle::Tensor x = this->GetSingleForwardInput("X"); + paddle::Tensor out_grad = this->GetSingleOutputGrad("Out"); + paddle::Tensor dx = this->GetSingleInputGrad("X"); auto *dx_ptr = this->GetOutputPtr(&dx); std::string dx_name = this->GetOutputName(dx); diff --git a/paddle/fluid/operators/slice_op.cc b/paddle/fluid/operators/slice_op.cc index 0b653d44bde..70223433b45 100644 --- a/paddle/fluid/operators/slice_op.cc +++ b/paddle/fluid/operators/slice_op.cc @@ -417,9 +417,9 @@ class SliceCompositeGradOpMaker : public prim::CompositeGradOpMakerBase { public: void Apply() override { - paddle::experimental::Tensor input = this->GetSingleForwardInput("Input"); - paddle::experimental::Tensor out_grad = this->GetSingleOutputGrad("Out"); - paddle::experimental::Tensor input_grad = this->GetSingleInputGrad("Input"); + paddle::Tensor input = this->GetSingleForwardInput("Input"); + paddle::Tensor out_grad = this->GetSingleOutputGrad("Out"); + paddle::Tensor input_grad = this->GetSingleInputGrad("Input"); auto dx_ptr = this->GetOutputPtr(&input_grad); std::string dx_name = this->GetOutputName(input_grad); diff --git a/paddle/fluid/operators/transpose_op.cc b/paddle/fluid/operators/transpose_op.cc index b47adef209b..7831ace09b2 100644 --- a/paddle/fluid/operators/transpose_op.cc +++ b/paddle/fluid/operators/transpose_op.cc @@ -307,10 +307,9 @@ class Transpose2CompositeGradOpMaker : public prim::CompositeGradOpMakerBase { public: void Apply() override { - paddle::experimental::Tensor xshape = - this->GetSingleForwardOutput("XShape"); - paddle::experimental::Tensor out_grad = this->GetSingleOutputGrad("Out"); - paddle::experimental::Tensor dx = this->GetSingleInputGrad("X"); + paddle::Tensor xshape = this->GetSingleForwardOutput("XShape"); + paddle::Tensor out_grad = this->GetSingleOutputGrad("Out"); + paddle::Tensor dx = this->GetSingleInputGrad("X"); auto *dx_ptr = this->GetOutputPtr(&dx); std::string dx_name = this->GetOutputName(dx); std::vector axis = diff --git a/paddle/fluid/prim/api/auto_code_generated/eager_gen.py b/paddle/fluid/prim/api/auto_code_generated/eager_gen.py index 6231157b198..e400d5797dc 100644 --- a/paddle/fluid/prim/api/auto_code_generated/eager_gen.py +++ b/paddle/fluid/prim/api/auto_code_generated/eager_gen.py @@ -356,7 +356,7 @@ namespace paddle { namespace prim { """, """ -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; using Scalar = paddle::experimental::Scalar; using IntArray = paddle::experimental::IntArray; using DataType = paddle::experimental::DataType; diff --git a/paddle/fluid/prim/api/auto_code_generated/tensor_operants_gen.py b/paddle/fluid/prim/api/auto_code_generated/tensor_operants_gen.py index 9d553f95305..6c883bc57c3 100644 --- a/paddle/fluid/prim/api/auto_code_generated/tensor_operants_gen.py +++ b/paddle/fluid/prim/api/auto_code_generated/tensor_operants_gen.py @@ -36,7 +36,7 @@ namespace paddle { namespace prim { -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; using Scalar = paddle::experimental::Scalar; using IntArray = paddle::experimental::IntArray; using TensorOperantsBase = paddle::operants::TensorOperantsBase; @@ -160,7 +160,7 @@ namespace paddle { namespace prim { -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; using Scalar = paddle::experimental::Scalar; using IntArray = paddle::experimental::IntArray; using TensorOperantsBase = paddle::operants::TensorOperantsBase; diff --git a/paddle/fluid/prim/api/composite_backward/composite_backward_api.h b/paddle/fluid/prim/api/composite_backward/composite_backward_api.h index 129f70428a0..6473d8501d6 100644 --- a/paddle/fluid/prim/api/composite_backward/composite_backward_api.h +++ b/paddle/fluid/prim/api/composite_backward/composite_backward_api.h @@ -20,9 +20,8 @@ #include "paddle/phi/core/ddim.h" namespace paddle { namespace prim { -using Tensor = paddle::experimental::Tensor; -using IntArray = - paddle::experimental::IntArrayBase; +using Tensor = paddle::Tensor; +using IntArray = paddle::experimental::IntArrayBase; // This function should have as same signature as phi, which defined in // paddle/phi/api/backward/backward_api.h template diff --git a/paddle/fluid/prim/api/manual_prim/prim_manual_api.h b/paddle/fluid/prim/api/manual_prim/prim_manual_api.h index 0e60955a69e..896a9cba102 100644 --- a/paddle/fluid/prim/api/manual_prim/prim_manual_api.h +++ b/paddle/fluid/prim/api/manual_prim/prim_manual_api.h @@ -24,7 +24,7 @@ namespace paddle { namespace prim { -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; using Scalar = paddle::experimental::Scalar; using IntArray = paddle::experimental::IntArray; using DataType = paddle::experimental::DataType; diff --git a/paddle/fluid/prim/api/manual_prim/utils/eager_utils.cc b/paddle/fluid/prim/api/manual_prim/utils/eager_utils.cc index 04854428d8e..ab85f8e2efe 100644 --- a/paddle/fluid/prim/api/manual_prim/utils/eager_utils.cc +++ b/paddle/fluid/prim/api/manual_prim/utils/eager_utils.cc @@ -30,7 +30,7 @@ Tensor empty(const paddle::experimental::IntArray& shape, } template <> -Tensor empty_like(const paddle::experimental::Tensor& x, +Tensor empty_like(const paddle::Tensor& x, paddle::experimental::DataType dtype, const paddle::Place& place) { if (dtype == paddle::experimental::DataType::UNDEFINED) { @@ -40,14 +40,13 @@ Tensor empty_like(const paddle::experimental::Tensor& x, } template <> -void set_output(const paddle::experimental::Tensor& x_tmp, - paddle::experimental::Tensor* x) { +void set_output(const paddle::Tensor& x_tmp, paddle::Tensor* x) { x->set_impl(x_tmp.impl()); x->set_autograd_meta(x_tmp.mutable_autograd_meta()); } template <> -void by_pass(const paddle::experimental::Tensor& x, Tensor* out) { +void by_pass(const paddle::Tensor& x, Tensor* out) { set_output(x, out); } diff --git a/paddle/fluid/prim/api/manual_prim/utils/static_utils.cc b/paddle/fluid/prim/api/manual_prim/utils/static_utils.cc index 8cfcffd92c2..fb2af799061 100644 --- a/paddle/fluid/prim/api/manual_prim/utils/static_utils.cc +++ b/paddle/fluid/prim/api/manual_prim/utils/static_utils.cc @@ -25,7 +25,7 @@ #include "paddle/phi/core/utils/data_type.h" namespace paddle { namespace prim { -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; template <> Tensor empty(const paddle::experimental::IntArray& shape, paddle::experimental::DataType dtype, @@ -48,14 +48,12 @@ Tensor empty_like(const Tensor& x, } template <> -void set_output(const paddle::experimental::Tensor& x_tmp, - paddle::experimental::Tensor* x) { +void set_output(const paddle::Tensor& x_tmp, paddle::Tensor* x) { x->set_impl(x_tmp.impl()); } template <> -void by_pass(const paddle::experimental::Tensor& x, - paddle::experimental::Tensor* out) { +void by_pass(const paddle::Tensor& x, paddle::Tensor* out) { Tensor new_out = empty({}, phi::DataType::FLOAT32, paddle::Place()); framework::BlockDesc* block = StaticCompositeContext::Instance().GetBlock(); diff --git a/paddle/fluid/prim/tests/test_eager_prim.cc b/paddle/fluid/prim/tests/test_eager_prim.cc index 63a524a6638..b9c898a74e1 100644 --- a/paddle/fluid/prim/tests/test_eager_prim.cc +++ b/paddle/fluid/prim/tests/test_eager_prim.cc @@ -63,7 +63,7 @@ TEST(EagerPrim, TanhBackwardTest) { paddle::prim::InitTensorOperants(); // 2. pre paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32}); - paddle::experimental::Tensor tensor0 = + paddle::Tensor tensor0 = ::egr::egr_utils_api::CreateTensorWithValue(ddim, paddle::platform::CPUPlace(), phi::DataType::FLOAT32, @@ -71,7 +71,7 @@ TEST(EagerPrim, TanhBackwardTest) { 5.0 /*value*/, true /*is_leaf*/); ::egr::egr_utils_api::RetainGradForTensor(tensor0); - paddle::experimental::Tensor tensor1 = + paddle::Tensor tensor1 = ::egr::egr_utils_api::CreateTensorWithValue(ddim, paddle::platform::CPUPlace(), phi::DataType::FLOAT32, @@ -80,16 +80,16 @@ TEST(EagerPrim, TanhBackwardTest) { true /*is_leaf*/); ::egr::egr_utils_api::RetainGradForTensor(tensor1); // 3. Run Forward once - paddle::experimental::Tensor out0 = tanh_ad_func(tensor0); - std::vector outs0 = {out0}; + paddle::Tensor out0 = tanh_ad_func(tensor0); + std::vector outs0 = {out0}; // Disable prim PrimCommonUtils::SetBwdPrimEnabled(false); ASSERT_FALSE(PrimCommonUtils::IsBwdPrimEnabled()); // 4. Run Backward egr::Backward(outs0, {}, false); - paddle::experimental::Tensor out1 = tanh_ad_func(tensor1); - std::vector outs1 = {out1}; + paddle::Tensor out1 = tanh_ad_func(tensor1); + std::vector outs1 = {out1}; // Enable prim PrimCommonUtils::SetBwdPrimEnabled(true); ASSERT_TRUE(PrimCommonUtils::IsBwdPrimEnabled()); @@ -120,7 +120,7 @@ TEST(EagerPrim, LogicalOperantsTest) { paddle::prim::InitTensorOperants(); // 2. pre paddle::framework::DDim ddim = phi::make_ddim({4, 16, 16, 32}); - paddle::experimental::Tensor tensor0 = + paddle::Tensor tensor0 = ::egr::egr_utils_api::CreateTensorWithValue(ddim, paddle::platform::CPUPlace(), phi::DataType::INT32, @@ -128,7 +128,7 @@ TEST(EagerPrim, LogicalOperantsTest) { 1 /*value*/, true /*is_leaf*/); ::egr::egr_utils_api::RetainGradForTensor(tensor0); - paddle::experimental::Tensor tensor1 = + paddle::Tensor tensor1 = ::egr::egr_utils_api::CreateTensorWithValue(ddim, paddle::platform::CPUPlace(), phi::DataType::INT32, @@ -137,8 +137,8 @@ TEST(EagerPrim, LogicalOperantsTest) { true /*is_leaf*/); ::egr::egr_utils_api::RetainGradForTensor(tensor1); // 3. Run Forward once - paddle::experimental::Tensor out0 = tensor0 & tensor1; - paddle::experimental::Tensor out1 = bitwise_and_ad_func(tensor0, tensor1); + paddle::Tensor out0 = tensor0 & tensor1; + paddle::Tensor out1 = bitwise_and_ad_func(tensor0, tensor1); EXPECT_EQ(out0.data()[0], out1.data()[0]); out0 = tensor0 | tensor1; out1 = bitwise_or_ad_func(tensor0, tensor1); diff --git a/paddle/fluid/prim/tests/test_static_prim.cc b/paddle/fluid/prim/tests/test_static_prim.cc index 5433378f70e..76ce33860c5 100644 --- a/paddle/fluid/prim/tests/test_static_prim.cc +++ b/paddle/fluid/prim/tests/test_static_prim.cc @@ -59,7 +59,7 @@ PD_DECLARE_KERNEL(bitwise_not, KPS, ALL_LAYOUT); namespace paddle { namespace prim { -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; struct TestBaseProgram { public: const framework::ProgramDesc& main_program() { return program_; } @@ -281,12 +281,11 @@ TEST(StaticCompositeGradMaker, TestMutiInputMethod) { target_block, grad_sub_block); test(); - std::vector muti_fw_input = - test.GetMultiForwardInput("X"); - std::vector> - opt_muti_fw_input = test.GetOptionalMultiForwardInput("X"); - paddle::experimental::Tensor fw_out = test.GetSingleForwardOutput("Out"); - paddle::experimental::Tensor* fw_out_ptr = test.GetOutputPtr(&fw_out); + std::vector muti_fw_input = test.GetMultiForwardInput("X"); + std::vector> opt_muti_fw_input = + test.GetOptionalMultiForwardInput("X"); + paddle::Tensor fw_out = test.GetSingleForwardOutput("Out"); + paddle::Tensor* fw_out_ptr = test.GetOutputPtr(&fw_out); std::string fw_out_name = test.GetOutputName(fw_out); ASSERT_EQ(muti_fw_input.size(), static_cast(2)); @@ -348,12 +347,11 @@ TEST(StaticCompositeGradMaker, TestMutiOutputMethod) { target_block, grad_sub_block); test(); - paddle::experimental::Tensor fw_input = test.GetSingleForwardInput("X"); - paddle::optional opt_fw_input = + paddle::Tensor fw_input = test.GetSingleForwardInput("X"); + paddle::optional opt_fw_input = test.GetOptionalSingleForwardInput("X"); - std::vector fw_out = - test.GetMultiForwardOutput("Out"); - std::vector fw_out_ptr(fw_out.size()); + std::vector fw_out = test.GetMultiForwardOutput("Out"); + std::vector fw_out_ptr(fw_out.size()); for (size_t i = 0; i < fw_out.size(); ++i) { fw_out_ptr[i] = &fw_out[i]; } diff --git a/paddle/fluid/prim/utils/static/composite_grad_desc_maker.h b/paddle/fluid/prim/utils/static/composite_grad_desc_maker.h index 91985e8543a..03edd06b71f 100644 --- a/paddle/fluid/prim/utils/static/composite_grad_desc_maker.h +++ b/paddle/fluid/prim/utils/static/composite_grad_desc_maker.h @@ -85,201 +85,185 @@ class CompositeGradOpMakerBase { virtual void Apply() = 0; - paddle::experimental::Tensor GetSingleForwardOutput(const std::string& name) { + paddle::Tensor GetSingleForwardOutput(const std::string& name) { framework::VarDesc* out_desc = this->SingleForwardOutput(name); - paddle::experimental::Tensor out = - paddle::experimental::Tensor(std::make_shared(out_desc)); + paddle::Tensor out = paddle::Tensor(std::make_shared(out_desc)); return out; } - paddle::experimental::Tensor GetSingleForwardInput(const std::string& name) { - paddle::experimental::Tensor input = paddle::experimental::Tensor( + paddle::Tensor GetSingleForwardInput(const std::string& name) { + paddle::Tensor input = paddle::Tensor( std::make_shared(this->SingleForwardInput(name))); return input; } - paddle::experimental::Tensor GetSingleOutputGrad(const std::string& name) { - paddle::experimental::Tensor output_grad = paddle::experimental::Tensor( + paddle::Tensor GetSingleOutputGrad(const std::string& name) { + paddle::Tensor output_grad = paddle::Tensor( std::make_shared(this->SingleOutputGrad(name))); return output_grad; } - paddle::experimental::Tensor GetSingleInputGrad(const std::string& name) { + paddle::Tensor GetSingleInputGrad(const std::string& name) { framework::VarDesc* input_grad_desc = this->SingleInputGrad(name); - if (!input_grad_desc) return paddle::experimental::Tensor(); - paddle::experimental::Tensor input_grad = paddle::experimental::Tensor( - std::make_shared(input_grad_desc)); + if (!input_grad_desc) return paddle::Tensor(); + paddle::Tensor input_grad = + paddle::Tensor(std::make_shared(input_grad_desc)); return input_grad; } - paddle::optional GetOptionalSingleForwardOutput( + paddle::optional GetOptionalSingleForwardOutput( const std::string& name) { - paddle::optional output_opt; + paddle::optional output_opt; if (fwd_op_.Outputs().find(name) != fwd_op_.Outputs().end()) { framework::VarDesc* output_desc = this->SingleForwardOutput(name); if (!output_desc) return output_opt; - paddle::experimental::Tensor output = paddle::experimental::Tensor( - std::make_shared(output_desc)); - output_opt = paddle::make_optional(output); + paddle::Tensor output = + paddle::Tensor(std::make_shared(output_desc)); + output_opt = paddle::make_optional(output); } return output_opt; } - paddle::optional GetOptionalSingleForwardInput( + paddle::optional GetOptionalSingleForwardInput( const std::string& name) { - paddle::optional input_opt; + paddle::optional input_opt; if (fwd_op_.Inputs().find(name) != fwd_op_.Inputs().end()) { framework::VarDesc* input_desc = this->SingleForwardInput(name); if (!input_desc) return input_opt; - paddle::experimental::Tensor input = paddle::experimental::Tensor( - std::make_shared(input_desc)); - input_opt = paddle::make_optional(input); + paddle::Tensor input = + paddle::Tensor(std::make_shared(input_desc)); + input_opt = paddle::make_optional(input); } return input_opt; } - paddle::optional GetOptionalSingleOutputGrad( + paddle::optional GetOptionalSingleOutputGrad( const std::string& name) { - paddle::optional output_grad_opt; + paddle::optional output_grad_opt; if (fwd_op_.Outputs().find(name) != fwd_op_.Outputs().end()) { framework::VarDesc* output_grad_desc = this->SingleOutputGrad(name); if (!output_grad_desc) return output_grad_opt; - paddle::experimental::Tensor output_grad = paddle::experimental::Tensor( - std::make_shared(output_grad_desc)); - output_grad_opt = - paddle::make_optional(output_grad); + paddle::Tensor output_grad = + paddle::Tensor(std::make_shared(output_grad_desc)); + output_grad_opt = paddle::make_optional(output_grad); } return output_grad_opt; } - std::vector GetMultiForwardOutput( - const std::string& name) { - std::vector outputs; + std::vector GetMultiForwardOutput(const std::string& name) { + std::vector outputs; std::vector outputs_descs = this->MultiForwardOutput(name); outputs.reserve(outputs_descs.size()); for (const auto& output_desc : outputs_descs) { - outputs.emplace_back(paddle::experimental::Tensor( - std::make_shared(output_desc))); + outputs.emplace_back( + paddle::Tensor(std::make_shared(output_desc))); } return outputs; } - std::vector GetMultiForwardInput( - const std::string& name) { - std::vector inputs; + std::vector GetMultiForwardInput(const std::string& name) { + std::vector inputs; std::vector inputs_descs = this->MultiForwardInput(name); inputs.reserve(inputs_descs.size()); for (const auto& input_desc : inputs_descs) { - inputs.emplace_back(paddle::experimental::Tensor( - std::make_shared(input_desc))); + inputs.emplace_back( + paddle::Tensor(std::make_shared(input_desc))); } return inputs; } - std::vector GetMultiOutputGrad( - const std::string& name) { - std::vector outputs_grads; + std::vector GetMultiOutputGrad(const std::string& name) { + std::vector outputs_grads; std::vector outputs_grads_descs = this->MultiOutputGrad(name); outputs_grads.reserve(outputs_grads_descs.size()); for (const auto& output_grad_desc : outputs_grads_descs) { - outputs_grads.emplace_back(paddle::experimental::Tensor( - std::make_shared(output_grad_desc))); + outputs_grads.emplace_back( + paddle::Tensor(std::make_shared(output_grad_desc))); } return outputs_grads; } - std::vector GetMultiInputGrad( - const std::string& name) { - std::vector inputs_grads; + std::vector GetMultiInputGrad(const std::string& name) { + std::vector inputs_grads; std::vector inputs_grads_descs = this->MultiInputGrad(name); inputs_grads.reserve(inputs_grads_descs.size()); for (const auto& input_grad_desc : inputs_grads_descs) { if (input_grad_desc) { - inputs_grads.emplace_back(paddle::experimental::Tensor( - std::make_shared(input_grad_desc))); + inputs_grads.emplace_back( + paddle::Tensor(std::make_shared(input_grad_desc))); } else { - inputs_grads.emplace_back(paddle::experimental::Tensor()); + inputs_grads.emplace_back(paddle::Tensor()); } } return inputs_grads; } - std::vector> - GetOptionalMultiForwardOutput(const std::string& name) { - std::vector> outputs_opt; + std::vector> GetOptionalMultiForwardOutput( + const std::string& name) { + std::vector> outputs_opt; std::vector outputs_descs = this->MultiForwardOutput(name); outputs_opt.reserve(outputs_descs.size()); for (const auto& output_desc : outputs_descs) { if (output_desc) { - outputs_opt.emplace_back( - paddle::make_optional( - paddle::experimental::Tensor( - std::make_shared(output_desc)))); + outputs_opt.emplace_back(paddle::make_optional( + paddle::Tensor(std::make_shared(output_desc)))); } else { outputs_opt.emplace_back( - paddle::make_optional( - paddle::experimental::Tensor())); + paddle::make_optional(paddle::Tensor())); } } return outputs_opt; } - std::vector> - GetOptionalMultiForwardInput(const std::string& name) { - std::vector> inputs_opt; + std::vector> GetOptionalMultiForwardInput( + const std::string& name) { + std::vector> inputs_opt; std::vector inputs_descs = this->MultiForwardInput(name); inputs_opt.reserve(inputs_descs.size()); for (const auto& input_desc : inputs_descs) { if (input_desc) { - inputs_opt.emplace_back( - paddle::make_optional( - paddle::experimental::Tensor( - std::make_shared(input_desc)))); + inputs_opt.emplace_back(paddle::make_optional( + paddle::Tensor(std::make_shared(input_desc)))); } else { inputs_opt.emplace_back( - paddle::make_optional( - paddle::experimental::Tensor())); + paddle::make_optional(paddle::Tensor())); } } return inputs_opt; } - std::vector> - GetOptionalMultiOutputGrad(const std::string& name) { - std::vector> outputs_grads; + std::vector> GetOptionalMultiOutputGrad( + const std::string& name) { + std::vector> outputs_grads; std::vector outputs_grads_descs = this->MultiOutputGrad(name); outputs_grads.reserve(outputs_grads_descs.size()); for (const auto& output_grad_desc : outputs_grads_descs) { if (output_grad_desc) { - outputs_grads.emplace_back( - paddle::make_optional( - paddle::experimental::Tensor( - std::make_shared(output_grad_desc)))); + outputs_grads.emplace_back(paddle::make_optional( + paddle::Tensor(std::make_shared(output_grad_desc)))); } else { outputs_grads.emplace_back( - paddle::make_optional( - paddle::experimental::Tensor())); + paddle::make_optional(paddle::Tensor())); } } return outputs_grads; } - paddle::experimental::Tensor* GetOutputPtr( - paddle::experimental::Tensor* input) { + paddle::Tensor* GetOutputPtr(paddle::Tensor* input) { if (input->defined()) return input; return nullptr; } - std::vector GetOutputPtr( - const std::vector& inputs) { - std::vector output_ptrs; + std::vector GetOutputPtr( + const std::vector& inputs) { + std::vector output_ptrs; output_ptrs.reserve(inputs.size()); for (const auto& input : inputs) { if (input->defined()) @@ -290,13 +274,13 @@ class CompositeGradOpMakerBase { return output_ptrs; } - std::string GetOutputName(const paddle::experimental::Tensor& output) { + std::string GetOutputName(const paddle::Tensor& output) { if (!output.defined()) return framework::kEmptyVarName; return static_cast(output.impl().get())->Name(); } std::vector GetOutputName( - const std::vector& outputs) { + const std::vector& outputs) { std::vector out_names; out_names.reserve(outputs.size()); for (const auto& output : outputs) { @@ -528,7 +512,7 @@ class CompositeGradOpMakerBase { return result; } - void RecoverOutputName(const paddle::experimental::Tensor& output, + void RecoverOutputName(const paddle::Tensor& output, const std::string& origin_name) { if (origin_name == framework::kEmptyVarName) return; VLOG(4) << "Recover: " @@ -539,9 +523,8 @@ class CompositeGradOpMakerBase { origin_name); } - void RecoverOutputName( - const std::vector& outputs, - const std::vector& origin_names) { + void RecoverOutputName(const std::vector& outputs, + const std::vector& origin_names) { PADDLE_ENFORCE_EQ(outputs.size(), origin_names.size(), platform::errors::InvalidArgument( diff --git a/paddle/fluid/pybind/distributed_py.cc b/paddle/fluid/pybind/distributed_py.cc index 0b4a14d51b0..3c201a7cdfb 100644 --- a/paddle/fluid/pybind/distributed_py.cc +++ b/paddle/fluid/pybind/distributed_py.cc @@ -59,7 +59,7 @@ namespace py = pybind11; namespace paddle { namespace pybind { -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; std::shared_ptr CreateEagerReducer( py::handle py_tensors, diff --git a/paddle/fluid/pybind/eager.cc b/paddle/fluid/pybind/eager.cc index fa7cd912fbe..cd980340c47 100644 --- a/paddle/fluid/pybind/eager.cc +++ b/paddle/fluid/pybind/eager.cc @@ -55,7 +55,7 @@ PyObject* TensorNew(PyTypeObject* type, PyObject* args, PyObject* kwargs) { PyObject* obj = type->tp_alloc(type, 0); if (obj) { auto v = reinterpret_cast(obj); - new (&(v->tensor)) paddle::experimental::Tensor(); + new (&(v->tensor)) paddle::Tensor(); } return obj; } @@ -189,7 +189,7 @@ void InitStringTensorWithNumpyValue(TensorObject* self, const py::object& obj) { } void InitTensorWithTensor(TensorObject* self, - const paddle::experimental::Tensor& src, + const paddle::Tensor& src, const paddle::platform::Place& place, const std::string& name) { self->tensor.set_name(name); @@ -218,8 +218,7 @@ void InitTensorWithFrameworkTensor(TensorObject* self, self->tensor.set_impl(std::make_shared(src)); VLOG(4) << "Same place, do ShareDataWith"; } else { - auto temp = - paddle::experimental::Tensor(std::make_shared(src)); + auto temp = paddle::Tensor(std::make_shared(src)); self->tensor.set_impl(temp.copy_to(place, true).impl()); VLOG(4) << "Different place, do TensorCopy"; } @@ -227,7 +226,7 @@ void InitTensorWithFrameworkTensor(TensorObject* self, } void InitStringTensorWithStringTensor(TensorObject* self, - const paddle::experimental::Tensor& src, + const paddle::Tensor& src, const paddle::platform::Place& place, const std::string& name) { self->tensor.set_name(name); @@ -412,7 +411,7 @@ void AutoInitTensorByTensor(TensorObject* py_tensor_ptr, act_name = ParseName(kws_map, kw_order_map, args, flag_kwargs, args_num); if (init_by_egr_tensor) { - paddle::experimental::Tensor src_tensor; + paddle::Tensor src_tensor; if (kw_order_map["value"] <= args_num) { src_tensor = CastPyArg2Tensor(PyTuple_GET_ITEM(args, kw_order_map["value"] - 1), @@ -509,7 +508,7 @@ void AutoInitStringTensorByStringTensor( flag_kwargs, args_num, "generated_string_tensor"); - paddle::experimental::Tensor src_tensor; + paddle::Tensor src_tensor; if (kw_order_map["value"] <= args_num) { src_tensor = CastPyArg2Tensor(PyTuple_GET_ITEM(args, kw_order_map["value"] - 1), diff --git a/paddle/fluid/pybind/eager_functions.cc b/paddle/fluid/pybind/eager_functions.cc index e68fd460b18..9a3229f3210 100644 --- a/paddle/fluid/pybind/eager_functions.cc +++ b/paddle/fluid/pybind/eager_functions.cc @@ -123,7 +123,7 @@ static PyObject* eager_api_scale(PyObject* self, float bias = CastPyArg2AttrFloat(PyTuple_GET_ITEM(args, 2), 2); bool bias_after_scale = CastPyArg2AttrBoolean(PyTuple_GET_ITEM(args, 3), 3); bool trace_backward = CastPyArg2AttrBoolean(PyTuple_GET_ITEM(args, 4), 4); - paddle::experimental::Tensor ret; + paddle::Tensor ret; { eager_gil_scoped_release guard; ret = egr::scale(tensor, scale, bias, bias_after_scale, trace_backward); @@ -159,7 +159,7 @@ static PyObject* eager_api_run_partial_grad(PyObject* self, auto only_inputs = CastPyArg2AttrBoolean(PyTuple_GET_ITEM(args, 5), 5); auto allow_unused = CastPyArg2AttrBoolean(PyTuple_GET_ITEM(args, 6), 6); auto no_grad_vars = CastPyArg2VectorOfTensor(PyTuple_GET_ITEM(args, 7), 7); - std::vector result; + std::vector result; { eager_gil_scoped_release guard; result = egr::Grad(tensors, @@ -180,9 +180,9 @@ static PyObject* eager_api_tensor_copy(PyObject* self, PyObject* args, PyObject* kwargs) { EAGER_TRY - paddle::experimental::Tensor& src = + paddle::Tensor& src = reinterpret_cast(PyTuple_GET_ITEM(args, 0))->tensor; - paddle::experimental::Tensor& dst = + paddle::Tensor& dst = reinterpret_cast(PyTuple_GET_ITEM(args, 1))->tensor; auto place = CastPyArg2Place(PyTuple_GET_ITEM(args, 2), 2); bool blocking = CastPyArg2AttrBoolean(PyTuple_GET_ITEM(args, 3), 3); @@ -205,18 +205,18 @@ PyObject* eager_api_get_all_grads(PyObject* self, EAGER_TRY auto tensor_list = CastPyArg2VectorOfTensor(PyTuple_GET_ITEM(args, 0), 0); - std::vector ret; + std::vector ret; for (auto& tensor : tensor_list) { VLOG(6) << "Get grad for tensor: " << tensor.name(); auto meta = egr::EagerUtils::nullable_autograd_meta(tensor); if (!meta || meta->StopGradient()) { - ret.emplace_back(paddle::experimental::Tensor()); + ret.emplace_back(paddle::Tensor()); continue; } if (meta && meta->Grad().initialized()) { ret.emplace_back(meta->Grad()); } else { - ret.emplace_back(paddle::experimental::Tensor()); + ret.emplace_back(paddle::Tensor()); } } return ToPyObject(ret, true); @@ -229,7 +229,7 @@ PyObject* eager_api_get_grads_lists(PyObject* self, EAGER_TRY auto tensor_list = CastPyArg2VectorOfTensor(PyTuple_GET_ITEM(args, 0), 0); // The order of the 3 vectors is: FP16_grads, BF16_grads, FP32_grads - std::vector> ret(3); + std::vector> ret(3); for (auto& tensor : tensor_list) { VLOG(6) << "Get grad for tensor: " << tensor.name(); @@ -298,13 +298,12 @@ static PyObject* eager_api_read_next_tensor_list(PyObject* self, EAGER_TRY auto tensor_base_list = CastPyArg2VectorOfTensorBase(PyTuple_GET_ITEM(args, 0), 0); - std::vector tensor_list; + std::vector tensor_list; { eager_gil_scoped_release guard; tensor_list.reserve(tensor_base_list.size()); auto func = [](phi::DenseTensor& tensor_base) { - paddle::experimental::Tensor tensor( - egr::Controller::Instance().GenerateUniqueName()); + paddle::Tensor tensor(egr::Controller::Instance().GenerateUniqueName()); auto autograd_meta = egr::EagerUtils::autograd_meta(&tensor); autograd_meta->SetPersistable(false); autograd_meta->SetStopGradient(true); @@ -486,9 +485,9 @@ static PyObject* eager_api_jit_function_call(PyObject* self, std::shared_ptr function = CastPyArg2JitFunction(PyTuple_GET_ITEM(args, 0), 0); - std::vector ins = + std::vector ins = CastPyArg2VectorOfTensor(PyTuple_GET_ITEM(args, 1), 1); - std::vector outs; + std::vector outs; { eager_gil_scoped_release guard; outs = (*function)(ins); @@ -571,9 +570,8 @@ static PyObject* eager_api_run_custom_op(PyObject* self, // Prepare Grad outputs size_t no_grad_cnt = 0; for (size_t i = 0; i < ins_auto_grad_metas.size(); i++) { - const std::vector& in_tensors = - ctx.InputsBetween(ctx.InputRangeAt(i).first, - ctx.InputRangeAt(i).second); + const std::vector& in_tensors = ctx.InputsBetween( + ctx.InputRangeAt(i).first, ctx.InputRangeAt(i).second); if (slot_map[0][0].find(i) != slot_map[0][0].end()) { grad_node->SetGradOutMeta(in_tensors, slot_map[0][0][i]); @@ -585,9 +583,8 @@ static PyObject* eager_api_run_custom_op(PyObject* self, } // Prepare Grad inputs with grad of fwd outputs for (size_t i = 0; i < outs_auto_grad_metas.size(); i++) { - const std::vector& out_tensors = - ctx.OutputsBetweeen(ctx.OutputRangeAt(i).first, - ctx.OutputRangeAt(i).second); + const std::vector& 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); @@ -638,7 +635,7 @@ static PyObject* eager_api_sparse_coo_tensor(PyObject* self, auto non_zero_elements = CastPyArg2Tensor(PyTuple_GET_ITEM(args, 1), 1); auto dense_shape = CastPyArg2VectorOfInt(PyTuple_GET_ITEM(args, 2), 2); auto stop_gradient = CastPyArg2AttrBoolean(PyTuple_GET_ITEM(args, 3), 3); - paddle::experimental::Tensor tensor; + paddle::Tensor tensor; { eager_gil_scoped_release guard; PADDLE_ENFORCE(non_zero_indices.is_dense_tensor(), @@ -682,7 +679,7 @@ static PyObject* eager_api_sparse_csr_tensor(PyObject* self, auto non_zero_elements = CastPyArg2Tensor(PyTuple_GET_ITEM(args, 2), 2); auto dense_shape = CastPyArg2VectorOfInt(PyTuple_GET_ITEM(args, 3), 3); auto stop_gradient = CastPyArg2AttrBoolean(PyTuple_GET_ITEM(args, 4), 4); - paddle::experimental::Tensor tensor; + paddle::Tensor tensor; { eager_gil_scoped_release guard; PADDLE_ENFORCE(non_zero_crows.is_dense_tensor(), @@ -895,9 +892,9 @@ static PyObject* eager_api_async_read(PyObject* self, } // Select the index data to the buffer - auto index_select = [](const paddle::experimental::Tensor& src_tensor, - const paddle::experimental::Tensor& index_tensor, - paddle::experimental::Tensor* buffer_tensor) { + auto index_select = [](const paddle::Tensor& src_tensor, + const paddle::Tensor& index_tensor, + paddle::Tensor* buffer_tensor) { auto* src_data = src_tensor.data(); auto* index_data = index_tensor.data(); auto* buffer_data = buffer_tensor->data(); @@ -1028,9 +1025,8 @@ static PyObject* eager_api_to_uva_tensor(PyObject* self, PyObject* kwargs) { EAGER_TRY VLOG(4) << "Running in eager_api_to_uva_tensor."; - auto new_tensor = std::shared_ptr( - new paddle::experimental::Tensor( - egr::Controller::Instance().GenerateUniqueName())); + auto new_tensor = std::shared_ptr( + new paddle::Tensor(egr::Controller::Instance().GenerateUniqueName())); PyObject* obj = PyTuple_GET_ITEM(args, 0); auto array = py::cast(py::handle(obj)); diff --git a/paddle/fluid/pybind/eager_math_op_patch.cc b/paddle/fluid/pybind/eager_math_op_patch.cc index 19afd128f56..8756abb5f36 100644 --- a/paddle/fluid/pybind/eager_math_op_patch.cc +++ b/paddle/fluid/pybind/eager_math_op_patch.cc @@ -166,11 +166,10 @@ void SetDevice(paddle::platform::Place place) { // scalar func only support add, radd, sub, rsub, mul, rmul, div, truediv. // this function will update gradually. -paddle::experimental::Tensor CallScalarFuction( - const paddle::experimental::Tensor& self_tensor, - double other, - std::string op_type) { - paddle::experimental::Tensor ret; +paddle::Tensor CallScalarFuction(const paddle::Tensor& self_tensor, + double other, + std::string op_type) { + paddle::Tensor ret; if (op_type == "add" || op_type == "radd") { ret = scale_ad_func(self_tensor, phi::Scalar(1.0), other, true); } else if (op_type == "sub") { @@ -203,8 +202,8 @@ static PyObject* tensor__add__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); // 1. scalar exists cases @@ -230,12 +229,12 @@ static PyObject* tensor__add__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (PyCheckTensor(other_obj)) { other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -305,8 +304,8 @@ static PyObject* tensor__sub__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); // 1. scalar exists cases @@ -331,12 +330,12 @@ static PyObject* tensor__sub__method(TensorObject* self, return ToPyObject(ret); } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (PyCheckTensor(other_obj)) { other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -402,8 +401,8 @@ static PyObject* tensor__rsub__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); // 1. scalar exists cases @@ -428,12 +427,12 @@ static PyObject* tensor__rsub__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (PyCheckTensor(other_obj)) { other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -500,8 +499,8 @@ static PyObject* tensor__mul__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); @@ -527,12 +526,12 @@ static PyObject* tensor__mul__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (PyCheckTensor(other_obj)) { other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -606,8 +605,8 @@ static PyObject* tensor__div__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); @@ -633,12 +632,12 @@ static PyObject* tensor__div__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (PyCheckTensor(other_obj)) { other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -721,8 +720,8 @@ static PyObject* tensor__rdiv__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); @@ -747,7 +746,7 @@ static PyObject* tensor__rdiv__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (has_other_double) { eager_gil_scoped_release guard; other_tensor = full_ad_func(self_tensor.shape(), @@ -758,7 +757,7 @@ static PyObject* tensor__rdiv__method(TensorObject* self, other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -840,8 +839,8 @@ static PyObject* tensor__gt__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); // 1. scalar exists cases @@ -865,7 +864,7 @@ static PyObject* tensor__gt__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (has_other_double) { eager_gil_scoped_release guard; other_tensor = full_ad_func(self_tensor.shape(), @@ -876,7 +875,7 @@ static PyObject* tensor__gt__method(TensorObject* self, other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -930,8 +929,8 @@ static PyObject* tensor__ge__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); // 1. scalar exists cases @@ -955,7 +954,7 @@ static PyObject* tensor__ge__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (has_other_double) { eager_gil_scoped_release guard; other_tensor = full_ad_func(self_tensor.shape(), @@ -966,7 +965,7 @@ static PyObject* tensor__ge__method(TensorObject* self, other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -1020,8 +1019,8 @@ static PyObject* tensor__mod__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); @@ -1046,7 +1045,7 @@ static PyObject* tensor__mod__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (has_other_double) { eager_gil_scoped_release guard; other_tensor = full_ad_func(self_tensor.shape(), @@ -1057,7 +1056,7 @@ static PyObject* tensor__mod__method(TensorObject* self, other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -1110,8 +1109,8 @@ static PyObject* tensor__matmul__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); @@ -1136,7 +1135,7 @@ static PyObject* tensor__matmul__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (has_other_double) { eager_gil_scoped_release guard; other_tensor = full_ad_func({1}, @@ -1147,7 +1146,7 @@ static PyObject* tensor__matmul__method(TensorObject* self, other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -1219,8 +1218,8 @@ static PyObject* tensor__lt__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); // 1. scalar exists cases @@ -1244,7 +1243,7 @@ static PyObject* tensor__lt__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (has_other_double) { eager_gil_scoped_release guard; other_tensor = full_ad_func(self_tensor.shape(), @@ -1255,7 +1254,7 @@ static PyObject* tensor__lt__method(TensorObject* self, other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -1309,8 +1308,8 @@ static PyObject* tensor__le__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); // 1. scalar exists cases @@ -1334,7 +1333,7 @@ static PyObject* tensor__le__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (has_other_double) { eager_gil_scoped_release guard; other_tensor = full_ad_func(self_tensor.shape(), @@ -1345,7 +1344,7 @@ static PyObject* tensor__le__method(TensorObject* self, other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -1398,8 +1397,8 @@ static PyObject* tensor__floordiv__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); @@ -1425,7 +1424,7 @@ static PyObject* tensor__floordiv__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (has_other_double) { eager_gil_scoped_release guard; other_tensor = full_ad_func(self_tensor.shape(), @@ -1436,7 +1435,7 @@ static PyObject* tensor__floordiv__method(TensorObject* self, other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -1493,8 +1492,8 @@ static PyObject* tensor__pow__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); @@ -1520,12 +1519,12 @@ static PyObject* tensor__pow__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (PyCheckTensor(other_obj)) { other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -1579,8 +1578,8 @@ static PyObject* tensor__rpow__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); @@ -1606,7 +1605,7 @@ static PyObject* tensor__rpow__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (has_other_double) { eager_gil_scoped_release guard; other_tensor = full_ad_func(self_tensor.shape(), @@ -1617,7 +1616,7 @@ static PyObject* tensor__rpow__method(TensorObject* self, other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -1671,8 +1670,8 @@ static PyObject* tensor__ne__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); // 1. scalar exists cases @@ -1696,7 +1695,7 @@ static PyObject* tensor__ne__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (has_other_double) { eager_gil_scoped_release guard; other_tensor = full_ad_func(self_tensor.shape(), @@ -1707,7 +1706,7 @@ static PyObject* tensor__ne__method(TensorObject* self, other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = @@ -1761,8 +1760,8 @@ static PyObject* tensor__eq__method(TensorObject* self, auto place = egr::Controller::Instance().GetExpectedPlace(); SetDevice(place); - paddle::experimental::Tensor ret; - paddle::experimental::Tensor self_tensor = self->tensor; + paddle::Tensor ret; + paddle::Tensor self_tensor = self->tensor; PyObject* other_obj = PyTuple_GET_ITEM(args, 0); // 1. scalar exists cases @@ -1786,7 +1785,7 @@ static PyObject* tensor__eq__method(TensorObject* self, } // 2. create or get tensor for other_obj - paddle::experimental::Tensor other_tensor; + paddle::Tensor other_tensor; if (has_other_double) { eager_gil_scoped_release guard; other_tensor = full_ad_func(self_tensor.shape(), @@ -1797,7 +1796,7 @@ static PyObject* tensor__eq__method(TensorObject* self, other_tensor = CastPyArg2Tensor(other_obj, 0); } else if (IsNumpyArray(other_obj)) { py::object numpy_value = py::object(py::handle(other_obj), true); - other_tensor = paddle::experimental::Tensor(place); + other_tensor = paddle::Tensor(place); InitTensorWithNumpyValue(numpy_value, place, &other_tensor); } else { paddle::experimental::Scalar value = diff --git a/paddle/fluid/pybind/eager_method.cc b/paddle/fluid/pybind/eager_method.cc index fbe77b3f906..2bf113ecc71 100644 --- a/paddle/fluid/pybind/eager_method.cc +++ b/paddle/fluid/pybind/eager_method.cc @@ -75,7 +75,7 @@ extern PyTypeObject* p_tensor_type; Py_ssize_t GetSliceIndexFromPyObject(PyObject* obj) { if (PyObject_IsInstance(obj, reinterpret_cast(p_tensor_type))) { VLOG(6) << "Call GetSliceIndexFromTensor in Eager"; - paddle::experimental::Tensor tensor = CastPyArg2Tensor(obj, 0); + paddle::Tensor tensor = CastPyArg2Tensor(obj, 0); PADDLE_ENFORCE_EQ( tensor.initialized(), true, @@ -87,7 +87,7 @@ Py_ssize_t GetSliceIndexFromPyObject(PyObject* obj) { CastPyArg2Tensor(obj, 0).impl().get()))); } else { PADDLE_THROW(platform::errors::InvalidArgument( - "We should only get paddle::experimental::Tensor or VarBase in this " + "We should only get paddle::Tensor or VarBase in this " "method, when you reach this means we got another type index.")); } } @@ -264,8 +264,7 @@ static PyObject* tensor_method_numpy(TensorObject* self, std::dynamic_pointer_cast(self->tensor.impl()); // TODO(qili93): temporary for ascned npu performance to be removed along // with npu_identity op - paddle::experimental::Tensor temp_tensor( - std::make_shared()); + paddle::Tensor temp_tensor(std::make_shared()); if (dense_tensor->storage_properties_initialized()) { temp_tensor = npu_identity_ad_func(self->tensor, -1); dense_tensor = @@ -381,7 +380,7 @@ static PyObject* tensor_method__is_dense_tensor_hold_allocation( } static void IncreaseTensorReferenceCountUntilCopyComplete( - const paddle::experimental::Tensor& tensor, const platform::Place& place) { + const paddle::Tensor& tensor, const platform::Place& place) { auto place_ = platform::is_gpu_place(place) ? place : tensor.place(); auto tracer = egr::Controller::Instance().GetCurrentTracer(); @@ -404,7 +403,7 @@ static PyObject* tensor_method__copy_to(TensorObject* self, EAGER_TRY auto place = CastPyArg2Place(PyTuple_GET_ITEM(args, 0), 0); bool blocking = CastPyArg2AttrBoolean(PyTuple_GET_ITEM(args, 1), 1); - paddle::experimental::Tensor cp_tensor; + paddle::Tensor cp_tensor; { eager_gil_scoped_release guard; cp_tensor = self->tensor.copy_to(place, blocking); @@ -424,7 +423,7 @@ static PyObject* tensor_method_cpu(TensorObject* self, PyObject* args, PyObject* kwargs) { EAGER_TRY - paddle::experimental::Tensor cp_tensor; + paddle::Tensor cp_tensor; { eager_gil_scoped_release guard; cp_tensor = self->tensor.copy_to(phi::CPUPlace(), true); @@ -441,8 +440,7 @@ static PyObject* tensor_method_reconstruct_from_(TensorObject* self, PyObject* args, PyObject* kwargs) { EAGER_TRY - paddle::experimental::Tensor src_tensor = - CastPyArg2Tensor(PyTuple_GET_ITEM(args, 0), 0); + paddle::Tensor src_tensor = CastPyArg2Tensor(PyTuple_GET_ITEM(args, 0), 0); std::string orig_name = self->tensor.name(); VLOG(6) << "Start Reconstructing Tensor from" << src_tensor.name() << " to " << orig_name; @@ -462,8 +460,7 @@ static PyObject* tensor_method_copy_(TensorObject* self, PyObject* args, PyObject* kwargs) { EAGER_TRY - paddle::experimental::Tensor src_tensor = - CastPyArg2Tensor(PyTuple_GET_ITEM(args, 0), 0); + paddle::Tensor src_tensor = CastPyArg2Tensor(PyTuple_GET_ITEM(args, 0), 0); bool blocking = CastPyArg2AttrBoolean(PyTuple_GET_ITEM(args, 1), 1); VLOG(6) << "Start Copy Tensor " << src_tensor.name() << " to " << self->tensor.name(); @@ -496,7 +493,7 @@ static PyObject* tensor_method_clone(TensorObject* self, PyObject* args, PyObject* kwargs) { EAGER_TRY - paddle::experimental::Tensor out; + paddle::Tensor out; { eager_gil_scoped_release guard; PADDLE_ENFORCE_EQ( @@ -544,7 +541,7 @@ static PyObject* tensor_clear_gradient(TensorObject* self, set_to_zero = CastPyArg2AttrBoolean(PyTuple_GET_ITEM(args, 0), 0); } - paddle::experimental::Tensor* grad; + paddle::Tensor* grad; bool is_leaf = egr::egr_utils_api::IsLeafTensor(self->tensor); if (is_leaf) { grad = egr::EagerUtils::mutable_grad(self->tensor); @@ -604,8 +601,7 @@ static PyObject* tensor__zero_grads(TensorObject* self, if (egr::egr_utils_api::IsLeafTensor(self->tensor)) { eager_gil_scoped_release guard; // Add RetainGrad as PostHook to AccumulationNode - paddle::experimental::Tensor* grad = - egr::EagerUtils::mutable_grad(self->tensor); + paddle::Tensor* grad = egr::EagerUtils::mutable_grad(self->tensor); PADDLE_ENFORCE(grad != nullptr, paddle::platform::errors::Fatal( "Detected NULL grad" @@ -645,7 +641,7 @@ static PyObject* tensor__share_buffer_to(TensorObject* self, PyObject* args, PyObject* kwargs) { EAGER_TRY - paddle::experimental::Tensor* dst_ptr = + paddle::Tensor* dst_ptr = &(reinterpret_cast(PyTuple_GET_ITEM(args, 0))->tensor); PADDLE_ENFORCE_EQ(self->tensor.initialized(), true, @@ -669,7 +665,7 @@ static PyObject* tensor__is_shared_buffer_with(TensorObject* self, PyObject* args, PyObject* kwargs) { EAGER_TRY - paddle::experimental::Tensor* dst_ptr = + paddle::Tensor* dst_ptr = &(reinterpret_cast(PyTuple_GET_ITEM(args, 0))->tensor); PADDLE_ENFORCE_EQ(self->tensor.initialized(), true, @@ -692,7 +688,7 @@ static PyObject* tensor__share_underline_tensor_to(TensorObject* self, PyObject* args, PyObject* kwargs) { EAGER_TRY - paddle::experimental::Tensor* src_ptr = + paddle::Tensor* src_ptr = &(reinterpret_cast(PyTuple_GET_ITEM(args, 0))->tensor); PADDLE_ENFORCE_EQ(self->tensor.initialized(), true, @@ -710,8 +706,7 @@ static PyObject* tensor__is_shared_underline_tensor_with(TensorObject* self, PyObject* args, PyObject* kwargs) { EAGER_TRY - paddle::experimental::Tensor src_tensor = - CastPyArg2Tensor(PyTuple_GET_ITEM(args, 0), 0); + paddle::Tensor src_tensor = CastPyArg2Tensor(PyTuple_GET_ITEM(args, 0), 0); PADDLE_ENFORCE_EQ(src_tensor.initialized(), true, platform::errors::InvalidArgument( @@ -740,7 +735,7 @@ static PyObject* tensor_method_detach(TensorObject* self, PyObject* obj = p_tensor_type->tp_alloc(p_tensor_type, 0); if (obj) { auto v = reinterpret_cast(obj); - new (&(v->tensor)) paddle::experimental::Tensor(); + new (&(v->tensor)) paddle::Tensor(); v->tensor.set_impl(self->tensor.impl()); v->tensor.set_name(egr::Controller::Instance().GenerateUniqueName()); auto autograd_meta_src = egr::EagerUtils::autograd_meta(&(self->tensor)); @@ -809,8 +804,7 @@ static PyObject* tensor_method__get_tensor_from_selected_rows( static_cast(selected_rows->mutable_value()); VLOG(4) << "dense_tensor: " << dense_tensor->IsInitialized(); - auto t = paddle::experimental::Tensor( - egr::Controller::Instance().GenerateUniqueName()); + auto t = paddle::Tensor(egr::Controller::Instance().GenerateUniqueName()); t.set_impl(std::make_shared(*dense_tensor)); return ToPyObject(t); @@ -850,10 +844,10 @@ static PyObject* tensor__getitem_index_not_tensor(TensorObject* self, &list_select_idxs, &list_select_flag); - auto out = slice_axes.empty() && !list_select_flag - ? self->tensor - : paddle::experimental::Tensor( - egr::Controller::Instance().GenerateUniqueName()); + auto out = + slice_axes.empty() && !list_select_flag + ? self->tensor + : paddle::Tensor(egr::Controller::Instance().GenerateUniqueName()); if (!slice_axes.empty()) { framework::AttributeMap attrs = {{"axes", slice_axes}, @@ -910,7 +904,7 @@ static PyObject* tensor__getitem_index_not_tensor(TensorObject* self, none_axes.pop_back(); } if (!none_axes.empty()) { - paddle::experimental::Tensor new_out; + paddle::Tensor new_out; { eager_gil_scoped_release guard; // Deal with cases that decrease_axes is not empty @@ -935,8 +929,8 @@ static PyObject* tensor__getitem_index_not_tensor(TensorObject* self, // the index is a list if (list_select_flag) { eager_gil_scoped_release guard; - auto select_index = paddle::experimental::Tensor( - egr::Controller::Instance().GenerateUniqueName()); + auto select_index = + paddle::Tensor(egr::Controller::Instance().GenerateUniqueName()); auto idx_tensor = std::make_shared(); select_index.set_impl(idx_tensor); auto* dev_ctx = platform::DeviceContextPool::Instance().Get( @@ -1135,12 +1129,12 @@ static PyObject* tensor_method__setitem_eager_tensor(TensorObject* self, self->tensor.name())); } - paddle::experimental::Tensor value_tensor; + paddle::Tensor value_tensor; if (PyCheckTensor(value_obj)) { value_tensor = reinterpret_cast(value_obj)->tensor; } else if (py::isinstance(value_obj)) { - paddle::experimental::Tensor value_tensor_tmp( + paddle::Tensor value_tensor_tmp( std::make_shared(), egr::Controller::Instance().GenerateUniqueName()); py::object value_obj_tmp(py::handle(value_obj), true); @@ -1234,7 +1228,7 @@ static PyObject* tensor_method__setitem_eager_tensor(TensorObject* self, // use inplace set_value_ operator if (value_tensor.initialized() && (self->tensor.dtype() != value_tensor.dtype())) { - paddle::small_vector, + paddle::small_vector, egr::kSlotSmallVectorSize> tmps = {{self->tensor}, {value_tensor}}; auto amp_dtype = egr::GetAmpDestDtype("set_value", tmps); @@ -1479,7 +1473,7 @@ static PyObject* tensor__use_gpudnn(TensorObject* self, target_dense_tensor.ShareDataWith(*dense_tensor); target_dense_tensor.set_meta(target_dense_meta); // Construct returned tensor - paddle::experimental::Tensor target_tensor( + paddle::Tensor target_tensor( std::make_shared(target_dense_tensor), self->tensor.name()); target_tensor.set_autograd_meta(self->tensor.mutable_autograd_meta()); @@ -1562,7 +1556,7 @@ static PyObject* tensor_method_get_non_zero_indices(TensorObject* self, "this method is only effective for SparseCooTensor")); auto sparse_coo_tensor = std::dynamic_pointer_cast(self->tensor.impl()); - paddle::experimental::Tensor tensor(std::make_shared( + paddle::Tensor tensor(std::make_shared( sparse_coo_tensor->non_zero_indices())); return ToPyObject(tensor); EAGER_CATCH_AND_THROW_RETURN_NULL @@ -1580,13 +1574,13 @@ static PyObject* tensor_method_get_non_zero_elements(TensorObject* self, if (self->tensor.is_sparse_coo_tensor()) { auto sparse_coo_tensor = std::dynamic_pointer_cast(self->tensor.impl()); - paddle::experimental::Tensor tensor(std::make_shared( + paddle::Tensor tensor(std::make_shared( sparse_coo_tensor->non_zero_elements())); return ToPyObject(tensor); } else { auto sparse_csr_tensor = std::dynamic_pointer_cast(self->tensor.impl()); - paddle::experimental::Tensor tensor(std::make_shared( + paddle::Tensor tensor(std::make_shared( sparse_csr_tensor->non_zero_elements())); return ToPyObject(tensor); } @@ -1602,7 +1596,7 @@ static PyObject* tensor_method_get_non_zero_crows(TensorObject* self, "this method is only effective for SparseCsrTensor")); auto sparse_csr_tensor = std::dynamic_pointer_cast(self->tensor.impl()); - paddle::experimental::Tensor tensor( + paddle::Tensor tensor( std::make_shared(sparse_csr_tensor->non_zero_crows())); return ToPyObject(tensor); EAGER_CATCH_AND_THROW_RETURN_NULL @@ -1617,7 +1611,7 @@ static PyObject* tensor_method_get_non_zero_cols(TensorObject* self, "this method is only effective for SparseCsrTensor")); auto sparse_csr_tensor = std::dynamic_pointer_cast(self->tensor.impl()); - paddle::experimental::Tensor tensor( + paddle::Tensor tensor( std::make_shared(sparse_csr_tensor->non_zero_cols())); return ToPyObject(tensor); EAGER_CATCH_AND_THROW_RETURN_NULL @@ -1755,8 +1749,7 @@ static PyObject* tensor__reset_grad_inplace_version(TensorObject* self, set_to_zero = CastPyArg2AttrBoolean(PyTuple_GET_ITEM(args, 0), 0); } - paddle::experimental::Tensor* grad = - egr::EagerUtils::mutable_grad(self->tensor); + paddle::Tensor* grad = egr::EagerUtils::mutable_grad(self->tensor); if (grad && grad->defined() && grad->is_dense_tensor() && grad->initialized()) { grad->reset_inplace_version(set_to_zero); @@ -1824,8 +1817,7 @@ static PyObject* tensor__grad_name(TensorObject* self, PyObject* args, PyObject* kwargs) { EAGER_TRY - paddle::experimental::Tensor* grad = - egr::EagerUtils::mutable_grad(self->tensor); + paddle::Tensor* grad = egr::EagerUtils::mutable_grad(self->tensor); PADDLE_ENFORCE_EQ(grad != nullptr, true, platform::errors::InvalidArgument( @@ -1839,8 +1831,7 @@ static PyObject* tensor__grad_value(TensorObject* self, PyObject* args, PyObject* kwargs) { EAGER_TRY - paddle::experimental::Tensor* grad = - egr::EagerUtils::mutable_grad(self->tensor); + paddle::Tensor* grad = egr::EagerUtils::mutable_grad(self->tensor); PADDLE_ENFORCE_EQ(grad != nullptr, true, platform::errors::InvalidArgument( @@ -1865,8 +1856,7 @@ static PyObject* tensor__unset_fake_empty(TensorObject* self, PyObject* args, PyObject* kwargs) { EAGER_TRY - paddle::experimental::Tensor* grad = - egr::EagerUtils::mutable_grad(self->tensor); + paddle::Tensor* grad = egr::EagerUtils::mutable_grad(self->tensor); PADDLE_ENFORCE_EQ(grad != nullptr, true, platform::errors::InvalidArgument( diff --git a/paddle/fluid/pybind/eager_properties.cc b/paddle/fluid/pybind/eager_properties.cc index e8fc670c491..26b43442664 100644 --- a/paddle/fluid/pybind/eager_properties.cc +++ b/paddle/fluid/pybind/eager_properties.cc @@ -118,8 +118,7 @@ int tensor_properties_set_grad(TensorObject* self, egr::egr_utils_api::IsLeafTensor(self->tensor), paddle::platform::errors::Fatal("Only leaf Tensor can be set grad.")); - paddle::experimental::Tensor* grad = - egr::EagerUtils::mutable_grad(self->tensor); + paddle::Tensor* grad = egr::EagerUtils::mutable_grad(self->tensor); PADDLE_ENFORCE(grad != nullptr, paddle::platform::errors::Fatal( "Detected NULL grad" diff --git a/paddle/fluid/pybind/eager_py_layer.cc b/paddle/fluid/pybind/eager_py_layer.cc index 28c1f179bc4..e28f9ac1c54 100644 --- a/paddle/fluid/pybind/eager_py_layer.cc +++ b/paddle/fluid/pybind/eager_py_layer.cc @@ -48,8 +48,8 @@ namespace py = ::pybind11; PyTypeObject* p_pylayer_type; extern PyTypeObject* p_tensor_type; -std::set GetTensorsFromPyObject(PyObject* obj) { - std::set result; +std::set GetTensorsFromPyObject(PyObject* obj) { + std::set result; if (obj == nullptr) { return result; } @@ -114,11 +114,11 @@ PyObject* pylayer_method_name(PyObject* self, PyObject* noargs) { EAGER_CATCH_AND_THROW_RETURN_NULL } -PyObject* new_tensor_with_impl(paddle::experimental::Tensor* tensor) { +PyObject* new_tensor_with_impl(paddle::Tensor* tensor) { PyObject* obj = p_tensor_type->tp_alloc(p_tensor_type, 0); if (obj) { auto v = reinterpret_cast(obj); - new (&(v->tensor)) paddle::experimental::Tensor(); + new (&(v->tensor)) paddle::Tensor(); v->tensor.set_impl(tensor->impl()); v->tensor.set_name(egr::Controller::Instance().GenerateUniqueName()); } else { @@ -169,7 +169,7 @@ PyObject* pylayer_method_apply(PyObject* cls, std::vector> inputs_autograd_meta; inputs_autograd_meta.reserve(inputs_size); - std::vector> inputs_tensor; + std::vector> inputs_tensor; inputs_tensor.reserve(inputs_size); ctx->forward_input_tensor_is_duplicable.clear(); ctx->forward_input_tensor_is_duplicable.reserve(inputs_size); @@ -196,7 +196,7 @@ PyObject* pylayer_method_apply(PyObject* cls, } ctx->forward_input_tensor_is_duplicable.push_back(false); } else if (PyList_Check(obj)) { - std::vector tensors; + std::vector tensors; Py_ssize_t len = PyList_Size(obj); for (Py_ssize_t j = 0; j < len; j++) { PyObject* o = PyList_GetItem(obj, j); @@ -219,7 +219,7 @@ PyObject* pylayer_method_apply(PyObject* cls, ctx->forward_input_tensor_is_duplicable.push_back(true); } } else if (PyTuple_Check(obj)) { - std::vector tensors; + std::vector tensors; Py_ssize_t len = PyTuple_Size(obj); for (Py_ssize_t j = 0; j < len; j++) { PyObject* o = PyTuple_GetItem(obj, j); @@ -280,7 +280,7 @@ PyObject* pylayer_method_apply(PyObject* cls, PyTuple_SET_ITEM(outputs_tuple, 0, outputs); } - std::set inplace_tensors; + std::set inplace_tensors; std::set not_inplace_tensorbases; auto not_inplace_tensors = GetTensorsFromPyObject(ctx->not_inplace_tensors); for (auto it : not_inplace_tensors) { @@ -288,7 +288,7 @@ PyObject* pylayer_method_apply(PyObject* cls, } auto outputs_size = PyTuple_GET_SIZE(outputs_tuple); - std::vector> outputs_tensor; + std::vector> outputs_tensor; outputs_tensor.reserve(outputs_size); std::vector> outputs_autograd_meta; outputs_autograd_meta.reserve(outputs_size); @@ -316,7 +316,7 @@ PyObject* pylayer_method_apply(PyObject* cls, } } } else if (PyList_Check(obj)) { - std::vector tensors; + std::vector tensors; Py_ssize_t len = PyList_Size(obj); for (Py_ssize_t j = 0; j < len; j++) { PyObject* o = PyList_GetItem(obj, j); @@ -344,7 +344,7 @@ PyObject* pylayer_method_apply(PyObject* cls, ctx->forward_output_tensor_is_duplicable.push_back(true); } } else if (PyTuple_Check(obj)) { - std::vector tensors; + std::vector tensors; Py_ssize_t len = PyTuple_Size(obj); for (Py_ssize_t j = 0; j < len; j++) { PyObject* o = PyTuple_GetItem(obj, j); diff --git a/paddle/fluid/pybind/eager_utils.cc b/paddle/fluid/pybind/eager_utils.cc index bef8e27bc71..8637b12f8aa 100644 --- a/paddle/fluid/pybind/eager_utils.cc +++ b/paddle/fluid/pybind/eager_utils.cc @@ -230,9 +230,9 @@ std::shared_ptr CastPyArg2JitFunction(PyObject* obj, } } -std::vector CastPyArg2VectorOfTensor( - PyObject* obj, ssize_t arg_pos) { - std::vector result; +std::vector CastPyArg2VectorOfTensor(PyObject* obj, + ssize_t arg_pos) { + std::vector result; if (PyList_Check(obj)) { Py_ssize_t len = PyList_Size(obj); PyObject* item = nullptr; @@ -644,7 +644,7 @@ PyObject* ToPyObject(const std::string& value) { return PyUnicode_FromString(value.c_str()); } -PyObject* ToPyObject(const paddle::experimental::Tensor& value, +PyObject* ToPyObject(const paddle::Tensor& value, PyObject* args, const std::map& inplace_var_idx_map) { if (!inplace_var_idx_map.empty() && inplace_var_idx_map.count(0)) { @@ -735,7 +735,7 @@ PyObject* ToPyObject(const std::vector>& value) { return result; } -PyObject* ToPyObject(const std::vector& value, +PyObject* ToPyObject(const std::vector& value, bool return_py_none_if_not_initialize) { PyObject* result = PyList_New((Py_ssize_t)value.size()); @@ -747,7 +747,7 @@ PyObject* ToPyObject(const std::vector& value, PyObject* obj = p_tensor_type->tp_alloc(p_tensor_type, 0); if (obj) { auto v = reinterpret_cast(obj); - new (&(v->tensor)) paddle::experimental::Tensor(); + new (&(v->tensor)) paddle::Tensor(); v->tensor = value[i]; } else { PADDLE_THROW(platform::errors::Fatal( @@ -760,9 +760,8 @@ PyObject* ToPyObject(const std::vector& value, return result; } -PyObject* ToPyObject( - const std::vector>& value, - bool return_py_none_if_not_initialize) { +PyObject* ToPyObject(const std::vector>& value, + bool return_py_none_if_not_initialize) { PyObject* result = PyList_New((Py_ssize_t)value.size()); for (size_t i = 0; i < value.size(); i++) { @@ -874,7 +873,7 @@ PyObject* ToPyObject(const paddle::framework::Vocab& value) { // For Final State Dygraph, // We directly use paddle::optional(Tensor) as dispensable Tensor -paddle::optional GetOptionalTensorFromArgs( +paddle::optional GetOptionalTensorFromArgs( const std::string& op_type, const std::string& arg_name, PyObject* args, @@ -898,7 +897,7 @@ paddle::optional GetOptionalTensorFromArgs( } if (PyObject_IsInstance(obj, reinterpret_cast(p_tensor_type))) { - return paddle::make_optional( + return paddle::make_optional( reinterpret_cast(obj)->tensor); } else { PADDLE_THROW(platform::errors::InvalidArgument( @@ -910,12 +909,11 @@ paddle::optional GetOptionalTensorFromArgs( } } -static paddle::experimental::Tensor& GetTensorFromPyObject( - const std::string& op_type, - const std::string& arg_name, - PyObject* obj, - ssize_t arg_idx, - bool dispensable) { +static paddle::Tensor& GetTensorFromPyObject(const std::string& op_type, + const std::string& arg_name, + PyObject* obj, + ssize_t arg_idx, + bool dispensable) { if (PyTuple_Check(obj)) { obj = PyTuple_GET_ITEM(obj, 0); } @@ -928,7 +926,7 @@ static paddle::experimental::Tensor& GetTensorFromPyObject( arg_name, arg_idx)); } - static paddle::experimental::Tensor emptytensor; + static paddle::Tensor emptytensor; return emptytensor; } @@ -949,21 +947,20 @@ static paddle::experimental::Tensor& GetTensorFromPyObject( // For Intermediate State Dygraph, // we use an uninitialized Tensor to represent dispensable Tensor -paddle::experimental::Tensor& GetTensorFromArgs(const std::string& op_type, - const std::string& arg_name, - PyObject* args, - ssize_t arg_idx, - bool dispensable) { +paddle::Tensor& GetTensorFromArgs(const std::string& op_type, + const std::string& arg_name, + PyObject* args, + ssize_t arg_idx, + bool dispensable) { PyObject* obj = PyTuple_GET_ITEM(args, arg_idx); return GetTensorFromPyObject(op_type, arg_name, obj, arg_idx, dispensable); } -std::vector GetTensorListFromArgs( - const std::string& op_type, - const std::string& arg_name, - PyObject* args, - ssize_t arg_idx, - bool dispensable) { +std::vector GetTensorListFromArgs(const std::string& op_type, + const std::string& arg_name, + PyObject* args, + ssize_t arg_idx, + bool dispensable) { PyObject* list = PyTuple_GET_ITEM(args, arg_idx); if (list == nullptr) { @@ -978,7 +975,7 @@ std::vector GetTensorListFromArgs( return {}; } - std::vector result; + std::vector result; if (PyList_Check(list)) { Py_ssize_t len = PyList_Size(list); @@ -1025,12 +1022,12 @@ std::vector GetTensorListFromArgs( return result; } -paddle::optional> -GetOptionalTensorListFromArgs(const std::string& op_type, - const std::string& arg_name, - PyObject* args, - ssize_t arg_idx, - bool dispensable) { +paddle::optional> GetOptionalTensorListFromArgs( + const std::string& op_type, + const std::string& arg_name, + PyObject* args, + ssize_t arg_idx, + bool dispensable) { PyObject* list = PyTuple_GET_ITEM(args, arg_idx); if (list == nullptr || list == Py_None) { @@ -1045,7 +1042,7 @@ GetOptionalTensorListFromArgs(const std::string& op_type, return paddle::none; } - std::vector result; + std::vector result; if (PyList_Check(list)) { Py_ssize_t len = PyList_Size(list); @@ -1090,11 +1087,11 @@ GetOptionalTensorListFromArgs(const std::string& op_type, return result; } -paddle::experimental::Tensor* GetTensorPtrFromArgs(const std::string& op_type, - const std::string& arg_name, - PyObject* args, - ssize_t arg_idx, - bool dispensable) { +paddle::Tensor* GetTensorPtrFromArgs(const std::string& op_type, + const std::string& arg_name, + PyObject* args, + ssize_t arg_idx, + bool dispensable) { PyObject* obj = PyTuple_GET_ITEM(args, arg_idx); if (PyTuple_Check(obj)) { @@ -1109,7 +1106,7 @@ paddle::experimental::Tensor* GetTensorPtrFromArgs(const std::string& op_type, arg_name, arg_idx)); } - static paddle::experimental::Tensor emptytensor; + static paddle::Tensor emptytensor; return &emptytensor; } @@ -1125,7 +1122,7 @@ paddle::experimental::Tensor* GetTensorPtrFromArgs(const std::string& op_type, } } -std::vector GetTensorPtrListFromArgs( +std::vector GetTensorPtrListFromArgs( const std::string& op_type, const std::string& arg_name, PyObject* args, @@ -1145,7 +1142,7 @@ std::vector GetTensorPtrListFromArgs( return {}; } - std::vector result; + std::vector result; if (PyList_Check(list)) { Py_ssize_t len = PyList_Size(list); @@ -1190,9 +1187,8 @@ std::vector GetTensorPtrListFromArgs( return result; } -std::vector GetTensorPtrListFromPyObject( - PyObject* obj) { - std::vector result; +std::vector GetTensorPtrListFromPyObject(PyObject* obj) { + std::vector result; if (PyList_Check(obj)) { Py_ssize_t len = PyList_Size(obj); @@ -1224,9 +1220,8 @@ std::vector GetTensorPtrListFromPyObject( return result; } -std::vector GetTensorListFromPyObject( - PyObject* obj) { - std::vector result; +std::vector GetTensorListFromPyObject(PyObject* obj) { + std::vector result; if (PyList_Check(obj)) { Py_ssize_t len = PyList_Size(obj); PyObject* item = nullptr; @@ -1268,7 +1263,7 @@ std::vector GetTensorListFromPyObject( return result; } -paddle::experimental::Tensor& GetTensorFromPyObject(PyObject* obj) { +paddle::Tensor& GetTensorFromPyObject(PyObject* obj) { if (!PyCheckTensor(obj)) { PADDLE_THROW(platform::errors::InvalidArgument( "argument must be " @@ -1350,7 +1345,7 @@ paddle::experimental::Scalar CastPyArg2Scalar(PyObject* obj, double value = CastPyArg2Double(obj, op_type, arg_pos); return paddle::experimental::Scalar(value); } else if (PyCheckTensor(obj)) { - paddle::experimental::Tensor& value = GetTensorFromPyObject( + paddle::Tensor& value = GetTensorFromPyObject( op_type, "" /*arg_name*/, obj, arg_pos, false /*dispensable*/); return paddle::experimental::Scalar(value); } else if (type_name.find("numpy") != std::string::npos) { @@ -1440,7 +1435,7 @@ paddle::experimental::IntArray CastPyArg2IntArray(PyObject* obj, std::vector value = CastPyArg2Longs(obj, op_type, arg_pos); return paddle::experimental::IntArray(value); } else if (type_name == "paddle.Tensor" || type_name == "Tensor") { - paddle::experimental::Tensor& value = GetTensorFromPyObject( + paddle::Tensor& value = GetTensorFromPyObject( op_type, "" /*arg_name*/, obj, arg_pos, false /*dispensable*/); return paddle::experimental::IntArray(value); } else if (PyObject_CheckLongOrConvertToLong(&obj)) { @@ -1545,8 +1540,7 @@ paddle::DataType CastPyArg2DataType(PyObject* obj, return framework::TransToPhiDataType(type); } -paddle::experimental::Tensor PyTensorHook::operator()( - const paddle::experimental::Tensor& var) { +paddle::Tensor PyTensorHook::operator()(const paddle::Tensor& var) { py::gil_scoped_acquire gil; VLOG(3) << "Call PyTensorHook for var " << var.name(); @@ -1627,7 +1621,7 @@ PackHook::~PackHook() { } std::shared_ptr PackHook::operator()( - const paddle::experimental::Tensor& tensor) { + const paddle::Tensor& tensor) { bool grad_tmp = egr::Controller::Instance().HasGrad(); egr::Controller::Instance().SetHasGrad(false); ::pybind11::gil_scoped_acquire gil; @@ -1665,7 +1659,7 @@ UnPackHook::~UnPackHook() { Py_DECREF(hook_); } -paddle::experimental::Tensor UnPackHook::operator()( +paddle::Tensor UnPackHook::operator()( std::shared_ptr packed_value) { bool grad_tmp = egr::Controller::Instance().HasGrad(); egr::Controller::Instance().SetHasGrad(false); diff --git a/paddle/fluid/pybind/eager_utils.h b/paddle/fluid/pybind/eager_utils.h index 513675a6664..9c1c0b8ba52 100644 --- a/paddle/fluid/pybind/eager_utils.h +++ b/paddle/fluid/pybind/eager_utils.h @@ -61,8 +61,8 @@ paddle::CustomOpKernelContext CastPyArg2CustomOpKernelContext(PyObject* obj, ssize_t arg_pos); std::shared_ptr CastPyArg2VarBase(PyObject* obj, ssize_t arg_pos); -std::vector CastPyArg2VectorOfTensor( - PyObject* obj, ssize_t arg_pos); +std::vector CastPyArg2VectorOfTensor(PyObject* obj, + ssize_t arg_pos); platform::Place CastPyArg2Place(PyObject* obj, ssize_t arg_pos); phi::DenseTensor CastPyArg2FrameworkTensor(PyObject* obj, ssize_t arg_pos); std::vector CastPyArg2VectorOfTensorBase(PyObject* obj, @@ -89,7 +89,7 @@ PyObject* ToPyObject(float value); PyObject* ToPyObject(double value); PyObject* ToPyObject(const char* value); PyObject* ToPyObject(const std::string& value); -PyObject* ToPyObject(const paddle::experimental::Tensor& value, +PyObject* ToPyObject(const paddle::Tensor& value, PyObject* args, const std::map& inplace_var_idx_map); PyObject* ToPyObject(PyObject* args, ssize_t arg_idx); @@ -100,11 +100,10 @@ PyObject* ToPyObject(const std::vector& value); PyObject* ToPyObject(const std::vector& value); PyObject* ToPyObject(const std::vector& value); PyObject* ToPyObject(const std::vector>& value); -PyObject* ToPyObject(const std::vector& value, +PyObject* ToPyObject(const std::vector& value, + bool return_py_none_if_not_initialize = false); +PyObject* ToPyObject(const std::vector>& value, bool return_py_none_if_not_initialize = false); -PyObject* ToPyObject( - const std::vector>& value, - bool return_py_none_if_not_initialize = false); PyObject* ToPyObject(const platform::Place& value); PyObject* ToPyObject(const phi::DenseTensor* value); PyObject* ToPyObject(const phi::SelectedRows* value); @@ -126,8 +125,7 @@ class PyTensorHook : public egr::TensorHook { Py_DECREF(py_func_); } - paddle::experimental::Tensor operator()( - const paddle::experimental::Tensor& var) override; + paddle::Tensor operator()(const paddle::Tensor& var) override; private: PyObject* py_func_; @@ -169,7 +167,7 @@ class PackHook : public egr::PackHookBase { ~PackHook(); std::shared_ptr operator()( - const paddle::experimental::Tensor& tensor) override; + const paddle::Tensor& tensor) override; void* operator()(void* py_tensor) override; @@ -183,7 +181,7 @@ class UnPackHook : public egr::UnPackHookBase { ~UnPackHook(); - paddle::experimental::Tensor operator()( + paddle::Tensor operator()( std::shared_ptr packed_value) override; void* operator()(void* packed_value, void* other) override; @@ -288,53 +286,50 @@ paddle::DataType CastPyArg2DataType(PyObject* obj, const std::string& op_type, ssize_t arg_pos); -paddle::optional GetOptionalTensorFromArgs( +paddle::optional GetOptionalTensorFromArgs( const std::string& op_type, const std::string& arg_name, PyObject* args, ssize_t arg_idx, bool dispensable = false); -paddle::experimental::Tensor& GetTensorFromArgs(const std::string& op_type, - const std::string& arg_name, - PyObject* args, - ssize_t arg_idx, - bool dispensable = false); +paddle::Tensor& GetTensorFromArgs(const std::string& op_type, + const std::string& arg_name, + PyObject* args, + ssize_t arg_idx, + bool dispensable = false); -paddle::optional> -GetOptionalTensorListFromArgs(const std::string& op_type, - const std::string& arg_name, - PyObject* args, - ssize_t arg_idx, - bool dispensable = false); - -std::vector GetTensorListFromArgs( +paddle::optional> GetOptionalTensorListFromArgs( const std::string& op_type, const std::string& arg_name, PyObject* args, ssize_t arg_idx, bool dispensable = false); -paddle::experimental::Tensor* GetTensorPtrFromArgs(const std::string& op_type, - const std::string& arg_name, - PyObject* args, - ssize_t arg_idx, - bool dispensable = false); +std::vector GetTensorListFromArgs(const std::string& op_type, + const std::string& arg_name, + PyObject* args, + ssize_t arg_idx, + bool dispensable = false); + +paddle::Tensor* GetTensorPtrFromArgs(const std::string& op_type, + const std::string& arg_name, + PyObject* args, + ssize_t arg_idx, + bool dispensable = false); -std::vector GetTensorPtrListFromArgs( +std::vector GetTensorPtrListFromArgs( const std::string& op_type, const std::string& arg_name, PyObject* args, ssize_t arg_idx, bool dispensable = false); -std::vector GetTensorPtrListFromPyObject( - PyObject* obj); +std::vector GetTensorPtrListFromPyObject(PyObject* obj); -std::vector GetTensorListFromPyObject( - PyObject* obj); +std::vector GetTensorListFromPyObject(PyObject* obj); -paddle::experimental::Tensor& GetTensorFromPyObject(PyObject* obj); +paddle::Tensor& GetTensorFromPyObject(PyObject* obj); // end of Slice related methods diff --git a/paddle/fluid/pybind/imperative.cc b/paddle/fluid/pybind/imperative.cc index d3db3befe96..6b5f5cb003c 100644 --- a/paddle/fluid/pybind/imperative.cc +++ b/paddle/fluid/pybind/imperative.cc @@ -350,7 +350,7 @@ Py_ssize_t GetSliceIndexFromPyObject(PyObject *obj) { .Get()); } else { PADDLE_THROW(platform::errors::InvalidArgument( - "We should only get paddle::experimental::Tensor or VarBase in this " + "We should only get paddle::Tensor or VarBase in this " "method, when you reach this means we got another type index.")); } } diff --git a/paddle/fluid/pybind/inference_api.cc b/paddle/fluid/pybind/inference_api.cc index eb9a0c0b338..f5712e3c651 100644 --- a/paddle/fluid/pybind/inference_api.cc +++ b/paddle/fluid/pybind/inference_api.cc @@ -279,9 +279,8 @@ void PaddleInferShareExternalData(paddle_infer::Tensor &tensor, // NOLINT } } -void PaddleTensorShareExternalData( - paddle_infer::Tensor &tensor, // NOLINT - paddle::experimental::Tensor &&paddle_tensor) { +void PaddleTensorShareExternalData(paddle_infer::Tensor &tensor, // NOLINT + paddle::Tensor &&paddle_tensor) { std::vector shape; for (int i = 0; i < paddle_tensor.dims().size(); ++i) { shape.push_back(paddle_tensor.dims()[i]); diff --git a/paddle/fluid/pybind/process_group_utils.h b/paddle/fluid/pybind/process_group_utils.h index 6e71984b043..3e4cdd743f4 100644 --- a/paddle/fluid/pybind/process_group_utils.h +++ b/paddle/fluid/pybind/process_group_utils.h @@ -232,7 +232,7 @@ void SplitDenseTensorWithType(const phi::XPUContext &dev_ctx, void ConcatTensor(const phi::DeviceContext &dev_ctx, const std::vector &tensor_list, - const experimental::Tensor *tensor) { + const Tensor *tensor) { auto *dense_tensor = std::dynamic_pointer_cast(tensor->impl()).get(); @@ -285,7 +285,7 @@ void ConcatTensor(const phi::DeviceContext &dev_ctx, void SplitTensor(const phi::DeviceContext &dev_ctx, const phi::DenseTensor &tensor, - const std::vector *tensor_list) { + const std::vector *tensor_list) { std::vector dense_list; for (auto &tensor : *tensor_list) { auto *p_tensor = diff --git a/paddle/fluid/pybind/tensor_py.h b/paddle/fluid/pybind/tensor_py.h index ac13fd054fc..f930fc32a47 100644 --- a/paddle/fluid/pybind/tensor_py.h +++ b/paddle/fluid/pybind/tensor_py.h @@ -663,10 +663,9 @@ void SetUVATensorFromPyArray( } template -void SetUVATensorFromPyArray( - const std::shared_ptr &self, - const py::array_t &array, - int device_id) { +void SetUVATensorFromPyArray(const std::shared_ptr &self, + const py::array_t &array, + int device_id) { #if defined(PADDLE_WITH_CUDA) VLOG(4) << "Running in SetUVATensorFromPyArray for Phi::Tensor."; phi::DenseTensorMeta meta = @@ -1174,11 +1173,9 @@ inline py::array TensorToPyArray(const phi::DenseTensor &tensor, // TODO(qili93): temporary for ascned npu performance to be removed along // with npu_identity op - paddle::experimental::Tensor tensor_out( - std::make_shared()); + paddle::Tensor tensor_out(std::make_shared()); if (tensor.storage_properties_initialized()) { - paddle::experimental::Tensor tensor_in( - std::make_shared(tensor)); + paddle::Tensor tensor_in(std::make_shared(tensor)); tensor_out = npu_identity_ad_func(tensor_in, -1); auto dense_tensor = std::dynamic_pointer_cast(tensor_out.impl()); diff --git a/paddle/phi/api/ext/op_meta_info.h b/paddle/phi/api/ext/op_meta_info.h index 978599c3bc2..95eddb97455 100644 --- a/paddle/phi/api/ext/op_meta_info.h +++ b/paddle/phi/api/ext/op_meta_info.h @@ -37,7 +37,7 @@ namespace framework { class PADDLE_API OpMetaInfoHelper; } // namespace framework -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; ///////////////// Util Marco Define //////////////// diff --git a/paddle/phi/api/ext/tensor_compat.h b/paddle/phi/api/ext/tensor_compat.h index f8c2b993d01..32db0712ccc 100644 --- a/paddle/phi/api/ext/tensor_compat.h +++ b/paddle/phi/api/ext/tensor_compat.h @@ -22,7 +22,6 @@ limitations under the License. */ // cannot be included in paddle namespace paddle { -using Tensor = experimental::Tensor; // using several Tensor initialize functions in paddle namespace using experimental::abs; using experimental::acos; diff --git a/paddle/phi/api/include/tensor.h b/paddle/phi/api/include/tensor.h index b3ddc03785a..67a607f5880 100644 --- a/paddle/phi/api/include/tensor.h +++ b/paddle/phi/api/include/tensor.h @@ -46,8 +46,9 @@ class DDim; } // namespace phi namespace paddle { - -namespace experimental { +// TODO(chenweihang): Remove the experimental namespace for Scalar and IntArray +using Scalar = experimental::Scalar; +using IntArray = experimental::IntArray; class AbstractAutogradMeta { public: @@ -721,5 +722,4 @@ PADDLE_API Tensor operator*(const Scalar& x, const Tensor& y); PADDLE_API Tensor operator/(const Scalar& x, const Tensor& y); -} // namespace experimental } // namespace paddle diff --git a/paddle/phi/api/lib/tensor.cc b/paddle/phi/api/lib/tensor.cc index 5b2c71b78d7..a63c2cc9cfe 100644 --- a/paddle/phi/api/lib/tensor.cc +++ b/paddle/phi/api/lib/tensor.cc @@ -36,7 +36,9 @@ limitations under the License. */ #include "paddle/phi/core/tensor_utils.h" namespace paddle { -namespace experimental { + +using DeviceContextPool = experimental::DeviceContextPool; +using DefaultAllocator = experimental::DefaultAllocator; /////// Tensor Methods //////// @@ -439,5 +441,4 @@ void Tensor::reset_inplace_version(bool set_to_zero) { } } -} // namespace experimental } // namespace paddle diff --git a/paddle/phi/api/lib/tensor_method.cc b/paddle/phi/api/lib/tensor_method.cc index 312f52fa5e6..5efd89d34e1 100644 --- a/paddle/phi/api/lib/tensor_method.cc +++ b/paddle/phi/api/lib/tensor_method.cc @@ -31,6 +31,10 @@ namespace experimental { // declare cast api Tensor cast(const Tensor &x, DataType out_dtype); Tensor copy_to(const Tensor &x, const Place &place, bool blocking); +} // namespace experimental + +// TODO(chenweihang): Remove this namespace using-directives later +using namespace experimental; // NOLINT Tensor Tensor::cast(DataType target_type) const { return experimental::cast(*this, target_type); @@ -207,5 +211,4 @@ Tensor Tensor::to_dense() const { return experimental::sparse::to_dense(*this); } -} // namespace experimental } // namespace paddle diff --git a/paddle/phi/api/yaml/generator/tensor_operants_gen.py b/paddle/phi/api/yaml/generator/tensor_operants_gen.py index a30bde15986..9a446a9f3bc 100644 --- a/paddle/phi/api/yaml/generator/tensor_operants_gen.py +++ b/paddle/phi/api/yaml/generator/tensor_operants_gen.py @@ -48,7 +48,7 @@ namespace paddle { namespace operants { -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; using Scalar = paddle::experimental::Scalar; using IntArray = paddle::experimental::IntArray; @@ -96,8 +96,6 @@ tensor_api_source_include = """// Generated by paddle/phi/api/yaml/generator/ten tensor_api_source_start = """ namespace paddle { -namespace experimental { - Tensor Tensor::operator+(const Tensor &other) const { return add(other); } @@ -193,7 +191,6 @@ PADDLE_API Tensor operator/(const Scalar& x, const Tensor& y) { tensor_api_source_end = """ -} // namespace experimental } // namespace paddle """ @@ -335,7 +332,7 @@ operants_manager_header_include = """// Generated by paddle/phi/api/yaml/generat operants_manager_header_start = """ namespace paddle { -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; using Scalar = paddle::experimental::Scalar; using IntArray = paddle::experimental::IntArray; using TensorOperantsBase = paddle::operants::TensorOperantsBase; diff --git a/paddle/phi/common/int_array.h b/paddle/phi/common/int_array.h index e7a928a987c..ce0076bd76c 100644 --- a/paddle/phi/common/int_array.h +++ b/paddle/phi/common/int_array.h @@ -20,6 +20,7 @@ limitations under the License. */ #include "paddle/phi/common/data_type.h" namespace paddle { +class Tensor; namespace experimental { template @@ -105,8 +106,7 @@ class IntArrayBase { bool is_from_tensor_{false}; }; -class Tensor; -using IntArray = paddle::experimental::IntArrayBase; +using IntArray = paddle::experimental::IntArrayBase; } // namespace experimental } // namespace paddle diff --git a/paddle/phi/common/scalar.h b/paddle/phi/common/scalar.h index eb417bbd3f5..953778a5706 100644 --- a/paddle/phi/common/scalar.h +++ b/paddle/phi/common/scalar.h @@ -21,6 +21,7 @@ limitations under the License. */ #include "paddle/phi/common/data_type.h" namespace paddle { +class Tensor; namespace experimental { template @@ -228,7 +229,6 @@ void CopyScalar(const ScalarBase& src, ScalarBase* dst) { dst->data_.c128 = src.data_.c128; } -class Tensor; using Scalar = paddle::experimental::ScalarBase; } // namespace experimental diff --git a/paddle/phi/tests/api/test_phi_tensor.cc b/paddle/phi/tests/api/test_phi_tensor.cc index e5388c96eec..657c24ca790 100644 --- a/paddle/phi/tests/api/test_phi_tensor.cc +++ b/paddle/phi/tests/api/test_phi_tensor.cc @@ -29,7 +29,7 @@ PD_DECLARE_KERNEL(empty, GPU, ALL_LAYOUT); namespace paddle { namespace tests { -using Tensor = paddle::experimental::Tensor; +using Tensor = paddle::Tensor; using DataType = paddle::experimental::DataType; template @@ -230,8 +230,7 @@ void TestDataInterface() { selected_rows->mutable_value()->Resize(phi::make_ddim({1, 1})); selected_rows->mutable_value()->mutable_data(phi::CPUPlace())[0] = static_cast(10.0f); - paddle::experimental::Tensor sr_tensor = - paddle::experimental::Tensor(selected_rows); + paddle::Tensor sr_tensor = paddle::Tensor(selected_rows); CHECK(sr_tensor.is_initialized() == true); tensor_ptr = sr_tensor.data(); CHECK(tensor_ptr != nullptr); @@ -240,7 +239,7 @@ void TestDataInterface() { } void TestJudgeTensorType() { - experimental::Tensor test_tensor(phi::CPUPlace(), {1, 1}); + Tensor test_tensor(phi::CPUPlace(), {1, 1}); CHECK(test_tensor.is_dense_tensor() == true); } diff --git a/paddle/phi/tests/api/test_strings_empty_api.cc b/paddle/phi/tests/api/test_strings_empty_api.cc index b7899af6ef7..02c77057351 100644 --- a/paddle/phi/tests/api/test_strings_empty_api.cc +++ b/paddle/phi/tests/api/test_strings_empty_api.cc @@ -51,7 +51,7 @@ TEST(API, strings_empty) { shape_data[0] = 2; shape_data[1] = 3; - paddle::experimental::Tensor tensor_shape(dense_shape); + paddle::Tensor tensor_shape(dense_shape); // 2. test API auto empty_out = paddle::experimental::strings::empty(tensor_shape); @@ -74,7 +74,7 @@ TEST(API, strings_empty_like) { alloc.get(), phi::StringTensorMeta(meta)); // 2. test API - paddle::experimental::Tensor x(cpu_strings_x); + paddle::Tensor x(cpu_strings_x); auto empty_like_out = paddle::experimental::strings::empty_like(x); // 3. check result diff --git a/paddle/phi/tests/api/test_strings_lower_upper_api.cc b/paddle/phi/tests/api/test_strings_lower_upper_api.cc index 327b16e5438..f81ab9dba94 100644 --- a/paddle/phi/tests/api/test_strings_lower_upper_api.cc +++ b/paddle/phi/tests/api/test_strings_lower_upper_api.cc @@ -63,7 +63,7 @@ TEST(API, case_convert) { std::transform( strs[1].begin(), strs[1].end(), expected_results[3].begin(), ::toupper); // 3. test API, ascii encoding - paddle::experimental::Tensor x(cpu_strings_x); + paddle::Tensor x(cpu_strings_x); auto lower_out = paddle::experimental::strings::lower(x, false); auto upper_out = paddle::experimental::strings::upper(x, false); @@ -111,7 +111,7 @@ TEST(API, case_convert_utf8) { "óósschloëëóósschloëëóósschloëë", "ÓÓSSCHLOËËÓÓSSCHLOËËÓÓSSCHLOËË"}; // 3. test API, ascii encoding - paddle::experimental::Tensor x(cpu_strings_x); + paddle::Tensor x(cpu_strings_x); auto lower_out = paddle::experimental::strings::lower(x, true); auto upper_out = paddle::experimental::strings::upper(x, true); diff --git a/paddle/phi/tests/api/test_to_api.cc b/paddle/phi/tests/api/test_to_api.cc index 23411784645..7a83003e118 100644 --- a/paddle/phi/tests/api/test_to_api.cc +++ b/paddle/phi/tests/api/test_to_api.cc @@ -28,7 +28,7 @@ namespace tests { namespace framework = paddle::framework; using DDim = phi::DDim; -paddle::experimental::Tensor CreateInputTensor() { +paddle::Tensor CreateInputTensor() { const auto alloc = std::make_unique(phi::CPUPlace()); auto dense_x = std::make_shared( @@ -43,10 +43,10 @@ paddle::experimental::Tensor CreateInputTensor() { dense_x_data[i] = i; } - return paddle::experimental::Tensor(dense_x); + return paddle::Tensor(dense_x); } -void CheckOutputResult(const paddle::experimental::Tensor& out) { +void CheckOutputResult(const paddle::Tensor& out) { ASSERT_EQ(out.dims().size(), 2); ASSERT_EQ(out.dims()[0], 3); ASSERT_EQ(out.dims()[1], 4); diff --git a/paddle/phi/tests/common/test_int_array.cc b/paddle/phi/tests/common/test_int_array.cc index c97eac38b13..9c32877c9e7 100644 --- a/paddle/phi/tests/common/test_int_array.cc +++ b/paddle/phi/tests/common/test_int_array.cc @@ -68,10 +68,10 @@ TEST(IntArray, ConstructFromCPUTensorVector) { auto shape0 = paddle::experimental::full({2}, 3, DataType::INT64); auto shape1 = paddle::experimental::full({2}, 3, DataType::INT32); - std::vector shape{shape0, shape0}; + std::vector shape{shape0, shape0}; auto out = paddle::experimental::full(shape, 1); - std::vector shape_new{shape0, shape1}; + std::vector shape_new{shape0, shape1}; auto out1 = paddle::experimental::full(shape_new, 1); ASSERT_EQ(out.dims().size(), 2); @@ -134,10 +134,10 @@ TEST(IntArray, ConstructFromGPUTensorVector) { auto shape0 = paddle::experimental::full({2}, 3, DataType::INT64, GPUPlace()); auto shape1 = paddle::experimental::full({2}, 3, DataType::INT32, GPUPlace()); - std::vector shape{shape0, shape0}; + std::vector shape{shape0, shape0}; auto out = paddle::experimental::full(shape, 1); - std::vector shape_new{shape0, shape1}; + std::vector shape_new{shape0, shape1}; auto out1 = paddle::experimental::full(shape_new, 1); ASSERT_EQ(out.dims().size(), 2); diff --git a/paddle/phi/tests/common/test_scalar.cu b/paddle/phi/tests/common/test_scalar.cu index 1eb9770f328..9fbcb99cece 100644 --- a/paddle/phi/tests/common/test_scalar.cu +++ b/paddle/phi/tests/common/test_scalar.cu @@ -173,7 +173,7 @@ TEST(Scalar, ConstructFromTensor) { auto* dense_x_data = dev_ctx->Alloc(dense_x.get()); FillTensor<<<1, 1, 0, dev_ctx->stream()>>>(dense_x_data); dev_ctx->Wait(); - paddle::experimental::Tensor x(dense_x); + paddle::Tensor x(dense_x); paddle::experimental::Scalar scalar_test(x); ASSERT_NEAR(1, scalar_test.to(), 1e-6); } diff --git a/paddle/utils/pybind.cc b/paddle/utils/pybind.cc index c67acffff0c..24b1c4f65c3 100644 --- a/paddle/utils/pybind.cc +++ b/paddle/utils/pybind.cc @@ -31,8 +31,7 @@ bool PyCheckTensor(PyObject* obj) { return PyObject_IsInstance(obj, reinterpret_cast(p_tensor_type)); } -paddle::experimental::Tensor CastPyArg2Tensor(PyObject* obj, - Py_ssize_t arg_pos) { +paddle::Tensor CastPyArg2Tensor(PyObject* obj, Py_ssize_t arg_pos) { if (PyObject_IsInstance(obj, reinterpret_cast(p_tensor_type)) || PyObject_IsInstance(obj, reinterpret_cast(p_string_tensor_type))) { @@ -46,7 +45,7 @@ paddle::experimental::Tensor CastPyArg2Tensor(PyObject* obj, } } -PyObject* ToPyObject(const paddle::experimental::Tensor& value, +PyObject* ToPyObject(const paddle::Tensor& value, bool return_py_none_if_not_initialize) { if (return_py_none_if_not_initialize && !value.initialized()) { RETURN_PY_NONE @@ -61,7 +60,7 @@ PyObject* ToPyObject(const paddle::experimental::Tensor& value, } if (obj) { auto v = reinterpret_cast(obj); - new (&(v->tensor)) paddle::experimental::Tensor(); + new (&(v->tensor)) paddle::Tensor(); v->tensor = value; } else { PADDLE_THROW( diff --git a/paddle/utils/pybind.h b/paddle/utils/pybind.h index 3bfe8cf07dc..4c4ef296a4e 100644 --- a/paddle/utils/pybind.h +++ b/paddle/utils/pybind.h @@ -27,7 +27,7 @@ namespace pybind { extern PyTypeObject* p_tensor_type; typedef struct { - PyObject_HEAD paddle::experimental::Tensor tensor; + PyObject_HEAD paddle::Tensor tensor; // Weak references PyObject* weakrefs; } TensorObject; @@ -40,11 +40,10 @@ typedef struct { bool PyCheckTensor(PyObject* obj); // Internal use only, to expose the Tensor type to Python. -paddle::experimental::Tensor CastPyArg2Tensor(PyObject* obj, - Py_ssize_t arg_pos); +paddle::Tensor CastPyArg2Tensor(PyObject* obj, Py_ssize_t arg_pos); // Internal use only, to expose the Tensor type to Python. -PyObject* ToPyObject(const paddle::experimental::Tensor& value, +PyObject* ToPyObject(const paddle::Tensor& value, bool return_py_none_if_not_initialize = false); // Internal use only, switch tensor_operants_mode to phi @@ -57,10 +56,9 @@ namespace pybind11 { namespace detail { template <> -struct type_caster { +struct type_caster { public: - PYBIND11_TYPE_CASTER(paddle::experimental::Tensor, - _("paddle::experimental::Tensor")); + PYBIND11_TYPE_CASTER(paddle::Tensor, _("paddle::Tensor")); bool load(handle src, bool) { paddle::pybind::EnableTensorOperantsToPhiMode(); @@ -72,7 +70,7 @@ struct type_caster { return false; } - static handle cast(const paddle::experimental::Tensor& src, + static handle cast(const paddle::Tensor& src, return_value_policy /* policy */, handle /* parent */) { return handle(paddle::pybind::ToPyObject( -- GitLab