rename op and api, remove inplace and view machanism for these 2 operators

Author: chenfeiyu

paddle/fluid/operators/complex_view_op.cc

@@ -24,13 +24,13 @@
 namespace paddle {
 namespace operators {
 
-class ViewAsComplexOp : public framework::OperatorWithKernel {
+class AsComplexOp : public framework::OperatorWithKernel {
  public:
  using framework::OperatorWithKernel::OperatorWithKernel;
 
  void InferShape(framework::InferShapeContext *ctx) const override {
- OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "view_as_complex");
- OP_INOUT_CHECK(ctx->HasOutput("Out"), "Output", "Out", "view_as_complex");
+ OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "as_complex");
+ OP_INOUT_CHECK(ctx->HasOutput("Out"), "Output", "Out", "as_complex");
 
  auto in_dims = ctx->GetInputDim("X");
  const int input_rank = in_dims.size();
@@ -57,15 +57,15 @@ class ViewAsComplexOp : public framework::OperatorWithKernel {
  }
 };
 
-class ViewAsComplexOpMaker : public framework::OpProtoAndCheckerMaker {
+class AsComplexOpMaker : public framework::OpProtoAndCheckerMaker {
  public:
  void Make() override {
  AddInput("X", "(Tensor), The input tensor of view_as_complex op.");
  AddOutput("Out", "(Tensor), The output tensor of view_as_complex op.");
  AddComment(R"DOC(
-View_as_complex Operator.
+As_complex Operator.
 
-This operator is used to return a complex tensor view represented
+This operator is used to return a complex tensor represented
 by an old-fashioned real tensor. The size of the last dimension of 
 the input tensor should be 2, which corresponds to 'real' and 
 'complex', respectively.
@@ -75,25 +75,25 @@ the input tensor should be 2, which corresponds to 'real' and
 };
 
 template <typename T>
-class ViewAsComplexGradMaker : public framework::SingleGradOpMaker<T> {
+class AsComplexGradMaker : public framework::SingleGradOpMaker<T> {
  public:
  using framework::SingleGradOpMaker<T>::SingleGradOpMaker;
 
  void Apply(GradOpPtr<T> retv) const override {
- retv->SetType("view_as_real");
+ retv->SetType("as_real");
  retv->SetInput("X", this->OutputGrad("Out"));
  retv->SetAttrMap(this->Attrs());
  retv->SetOutput("Out", this->InputGrad("X"));
  }
 };
 
-class ViewAsRealOp : public framework::OperatorWithKernel {
+class AsRealOp : public framework::OperatorWithKernel {
  public:
  using framework::OperatorWithKernel::OperatorWithKernel;
 
  void InferShape(framework::InferShapeContext *ctx) const override {
- OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "view_as_real");
- OP_INOUT_CHECK(ctx->HasOutput("Out"), "Output", "Out", "view_as_real");
+ OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "as_real");
+ OP_INOUT_CHECK(ctx->HasOutput("Out"), "Output", "Out", "as_real");
 
  auto out_dims_v = framework::vectorize(ctx->GetInputDim("X"));
  out_dims_v.push_back(2);
@@ -112,15 +112,15 @@ class ViewAsRealOp : public framework::OperatorWithKernel {
  }
 };
 
-class ViewAsRealOpMaker : public framework::OpProtoAndCheckerMaker {
+class AsRealOpMaker : public framework::OpProtoAndCheckerMaker {
  public:
  void Make() override {
- AddInput("X", "(Tensor), The input tensor of view_as_real op.");
- AddOutput("Out", "(Tensor), The output tensor of view_as_real op.");
+ AddInput("X", "(Tensor), The input tensor of as_real op.");
+ AddOutput("Out", "(Tensor), The output tensor of as_real op.");
  AddComment(R"DOC(
-View_as_real Operator.
+AsReal Operator.
 
-This operator is used to return an old-fashioned real tensor view of a 
+This operator is used to return an old-fashioned real tensor from a 
 complex tensor. The size of the last dimension of the output tensor is 2,
 which corresponds to 'real' and 'complex', respectively.
 
@@ -129,12 +129,12 @@ which corresponds to 'real' and 'complex', respectively.
 };
 
 template <typename T>
-class ViewAsRealGradMaker : public framework::SingleGradOpMaker<T> {
+class AsRealGradMaker : public framework::SingleGradOpMaker<T> {
  public:
  using framework::SingleGradOpMaker<T>::SingleGradOpMaker;
 
  void Apply(GradOpPtr<T> retv) const override {
- retv->SetType("view_as_complex");
+ retv->SetType("as_complex");
  retv->SetInput("X", this->OutputGrad("Out"));
  retv->SetAttrMap(this->Attrs());
  retv->SetOutput("Out", this->InputGrad("X"));
@@ -146,23 +146,18 @@ class ViewAsRealGradMaker : public framework::SingleGradOpMaker<T> {
 
 namespace ops = paddle::operators;
 
-REGISTER_OPERATOR(view_as_complex, ops::ViewAsComplexOp,
- ops::ViewAsComplexOpMaker,
- ops::ViewAsComplexGradMaker<paddle::framework::OpDesc>,
- ops::ViewAsComplexGradMaker<paddle::imperative::OpBase>,
- ops::ViewAsComplexOpInplaceInferer);
+REGISTER_OPERATOR(as_complex, ops::AsComplexOp, ops::AsComplexOpMaker,
+ ops::AsComplexGradMaker<paddle::framework::OpDesc>,
+ ops::AsComplexGradMaker<paddle::imperative::OpBase>);
 
-REGISTER_OPERATOR(view_as_real, ops::ViewAsRealOp, ops::ViewAsRealOpMaker,
- ops::ViewAsRealGradMaker<paddle::framework::OpDesc>,
- ops::ViewAsRealGradMaker<paddle::imperative::OpBase>,
- ops::ViewAsRealOpInplaceInferer);
+REGISTER_OPERATOR(as_real, ops::AsRealOp, ops::AsRealOpMaker,
+ ops::AsRealGradMaker<paddle::framework::OpDesc>,
+ ops::AsRealGradMaker<paddle::imperative::OpBase>);
 
 REGISTER_OP_CPU_KERNEL(
- view_as_complex,
- ops::ViewAsComplexKernel<paddle::platform::CPUDeviceContext, float>,
- ops::ViewAsComplexKernel<paddle::platform::CPUDeviceContext, double>);
+ as_complex, ops::AsComplexKernel<paddle::platform::CPUDeviceContext, float>,
+ ops::AsComplexKernel<paddle::platform::CPUDeviceContext, double>);
 
 REGISTER_OP_CPU_KERNEL(
- view_as_real,
- ops::ViewAsRealKernel<paddle::platform::CPUDeviceContext, float>,
- ops::ViewAsRealKernel<paddle::platform::CPUDeviceContext, double>);
+ as_real, ops::AsRealKernel<paddle::platform::CPUDeviceContext, float>,
+ ops::AsRealKernel<paddle::platform::CPUDeviceContext, double>);

paddle/fluid/operators/complex_view_op.cu

@@ -20,11 +20,10 @@
 namespace ops = paddle::operators;
 
 REGISTER_OP_CUDA_KERNEL(
- view_as_complex,
- ops::ViewAsComplexKernel<paddle::platform::CUDADeviceContext, float>,
- ops::ViewAsComplexKernel<paddle::platform::CUDADeviceContext, double>);
+ as_complex,
+ ops::AsComplexKernel<paddle::platform::CUDADeviceContext, float>,
+ ops::AsComplexKernel<paddle::platform::CUDADeviceContext, double>);
 
 REGISTER_OP_CUDA_KERNEL(
- view_as_real,
- ops::ViewAsRealKernel<paddle::platform::CUDADeviceContext, float>,
- ops::ViewAsRealKernel<paddle::platform::CUDADeviceContext, double>);
+ as_real, ops::AsRealKernel<paddle::platform::CUDADeviceContext, float>,
+ ops::AsRealKernel<paddle::platform::CUDADeviceContext, double>);

paddle/fluid/operators/complex_view_op.h

@@ -25,7 +25,7 @@ namespace paddle {
 namespace operators {
 
 template <typename DeviceContext, typename T>
-class ViewAsComplexKernel : public framework::OpKernel<T> {
+class AsComplexKernel : public framework::OpKernel<T> {
  public:
  void Compute(const framework::ExecutionContext& context) const override {
  const auto* x = context.Input<framework::LoDTensor>("X");
@@ -42,7 +42,7 @@ class ViewAsComplexKernel : public framework::OpKernel<T> {
 };
 
 template <typename DeviceContext, typename T>
-class ViewAsRealKernel : public framework::OpKernel<T> {
+class AsRealKernel : public framework::OpKernel<T> {
  public:
  void Compute(const framework::ExecutionContext& context) const override {
  const auto* x = context.Input<framework::LoDTensor>("X");
@@ -56,8 +56,5 @@ class ViewAsRealKernel : public framework::OpKernel<T> {
  }
 };
 
-DECLARE_INPLACE_OP_INFERER(ViewAsComplexOpInplaceInferer, {"X", "Out"});
-DECLARE_INPLACE_OP_INFERER(ViewAsRealOpInplaceInferer, {"X", "Out"});
-
 } // namespace operators
 } // namespace paddle

paddle/fluid/pybind/op_function_generator.cc

@@ -32,78 +32,6 @@
 #include "paddle/fluid/framework/fleet/ascend_wrapper.h"
 #endif
 
-// NOTE(zhiqiu): Commonly, the outputs in auto-generated OP function are
-// generated in C++ automatically.
-// However, some OPs need to pass the outputs from Python instead of generating
-// them in C++. There are mainly 2 reasons for that,
-// (1) Optimizer OPs need to update the input param in-place, like sgd.
-// So they need to pass the output which is same as input param.
-// (2) Very few python APIs has out in their arguments, like fill_constant.
-// So they need to pass the python output to C++.
-// Actually, this is not a good design, since it may break the SSA graph,
-// especially in declarative mode.
-// For those OPs, we need to manually specify the outs need to pass in this map.
-std::map<std::string, std::set<std::string>> op_passing_outs_map = {
- {"sgd", {"ParamOut"}},
- {"adam",
- {"ParamOut", "Moment1Out", "Moment2Out", "Beta1PowOut", "Beta2PowOut",
- "MasterParamOut"}},
- {"adamw",
- {"ParamOut", "Moment1Out", "Moment2Out", "Beta1PowOut", "Beta2PowOut",
- "MasterParamOut"}},
- {"average_accumulates",
- {"out_sum_1", "out_sum_2", "out_sum_3", "out_num_accumulates",
- "out_old_num_accumulates", "out_num_updates"}},
- {"momentum", {"ParamOut", "VelocityOut", "MasterParamOut"}},
- {"sparse_momentum", {"ParamOut", "VelocityOut"}},
- {"batch_norm", {"MeanOut", "VarianceOut"}},
- {"sync_batch_norm", {"MeanOut", "VarianceOut"}},
- {"accuracy", {"Correct", "Total"}},
- {"fill_constant", {"Out"}},
- {"recv_v2", {"Out"}},
- {"partial_recv", {"Out"}},
- {"matmul", {"Out"}},
- {"c_broadcast", {"Out"}},
- {"c_sync_calc_stream", {"Out"}},
- {"c_sync_comm_stream", {"Out"}},
- {"c_reduce_sum", {"Out"}},
- {"c_reduce_max", {"Out"}},
- {"c_reduce_min", {"Out"}},
- {"c_reduce_prod", {"Out"}},
- {"c_reduce", {"Out"}},
- {"c_scatter", {"Out"}},
- {"barrier", {"Out"}},
- {"fake_quantize_dequantize_moving_average_abs_max",
- {"Out", "OutScale", "OutAccum", "OutState"}},
- {"fake_quantize_dequantize_abs_max", {"Out", "OutScale"}},
- {"fake_channel_wise_quantize_dequantize_abs_max", {"Out", "OutScale"}},
- {"check_finite_and_unscale", {"Out", "FoundInfinite"}},
- {"update_loss_scaling",
- {"Out", "LossScaling", "OutGoodSteps", "OutBadSteps"}},
- {"moving_average_abs_max_scale",
- {"Out", "OutScale", "OutAccum", "OutState"}},
- {"lamb",
- {"ParamOut", "Moment1Out", "Moment2Out", "Beta1PowOut", "Beta2PowOut"}},
- {"rnn", {"DropoutState"}},
- {"run_program", {"Out", "DOut", "OutScope"}},
- {"clear_float_status", {"FloatStatusOut"}},
- {"get_float_status", {"FloatStatusOut"}},
-};
-
-// NOTE(pangyoki): Tensor View Strategy.
-// In this case, a new output varbase will be created, and this varbase will
-// reuse the input varbase's allocation.
-// It's a map. The key of outer map is the view op name, the value is
-// a pair which implies the mapping relationship between the input and
-// output varbase.
-std::map<std::string, std::pair<std::string, std::string>> view_op_map = {
- {"squeeze2", {"X", "Out"}}, // "X" -> "Out"
- {"unsqueeze2", {"X", "Out"}},
- {"reshape2", {"X", "Out"}},
- {"flatten_contiguous_range", {"X", "Out"}},
- {"view_as_complex", {"X", "Out"}},
- {"view_as_real", {"X", "Out"}}};
-
 // NOTE(pangyoki): Inplace OP with duplicable input.
 // The set includes inplace ops that have duplicable input.
 // The first Varbase in input needs to be specified for the inplace strategy

python/paddle/__init__.py

@@ -155,8 +155,8 @@
 from .tensor.manipulation import chunk # noqa: F401
 from .tensor.manipulation import tolist # noqa: F401
 from .tensor.manipulation import tensordot # noqa: F401
-from .tensor.manipulation import view_as_complex # noqa: F401
-from .tensor.manipulation import view_as_real # noqa: F401
+from .tensor.manipulation import as_complex # noqa: F401
+from .tensor.manipulation import as_real # noqa: F401
 
 from .tensor.math import abs # noqa: F401
 from .tensor.math import acos # noqa: F401
@@ -541,8 +541,8 @@
  'einsum',
  'set_flags',
  'get_flags',
- 'view_as_complex',
- 'view_as_real',
+ 'as_complex',
+ 'as_real',
  'diff',
  'angle',
 ]

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

@@ -35,7 +35,7 @@ def ref_view_as_real(x):
 
 class TestViewAsComplexOp(OpTest):
  def setUp(self):
- self.op_type = "view_as_complex"
+ self.op_type = "as_complex"
  x = np.random.randn(10, 10, 2).astype("float64")
  out_ref = ref_view_as_complex(x)
  self.out_grad = np.ones(
@@ -57,7 +57,7 @@ def test_check_grad(self):
 
 class TestViewAsRealOp(OpTest):
  def setUp(self):
- self.op_type = "view_as_real"
+ self.op_type = "as_real"
  real = np.random.randn(10, 10).astype("float64")
  imag = np.random.randn(10, 10).astype("float64")
  x = real + 1j * imag
@@ -85,14 +85,14 @@ def setUp(self):
  def test_dygraph(self):
  with dygraph.guard():
  x = paddle.to_tensor(self.x)
- out_np = paddle.view_as_complex(x).numpy()
+ out_np = paddle.as_complex(x).numpy()
  self.assertTrue(np.allclose(self.out, out_np))
 
  def test_static(self):
  mp, sp = static.Program(), static.Program()
  with static.program_guard(mp, sp):
  x = static.data("x", shape=[10, 10, 2], dtype="float64")
- out = paddle.view_as_complex(x)
+ out = paddle.as_complex(x)
 
  exe = static.Executor()
  exe.run(sp)
@@ -108,14 +108,14 @@ def setUp(self):
  def test_dygraph(self):
  with dygraph.guard():
  x = paddle.to_tensor(self.x)
- out_np = paddle.view_as_real(x).numpy()
+ out_np = paddle.as_real(x).numpy()
  self.assertTrue(np.allclose(self.out, out_np))
 
  def test_static(self):
  mp, sp = static.Program(), static.Program()
  with static.program_guard(mp, sp):
  x = static.data("x", shape=[10, 10], dtype="complex128")
- out = paddle.view_as_real(x)
+ out = paddle.as_real(x)
 
  exe = static.Executor()
  exe.run(sp)