diff --git a/paddle/fluid/operators/triangular_solve_op.cc b/paddle/fluid/operators/triangular_solve_op.cc deleted file mode 100644 index 66e4c3a57890e3f143476d468c04a6cef6fc04eb..0000000000000000000000000000000000000000 --- a/paddle/fluid/operators/triangular_solve_op.cc +++ /dev/null @@ -1,135 +0,0 @@ -/* Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. */ - -#include "paddle/fluid/framework/infershape_utils.h" -#include "paddle/fluid/framework/op_registry.h" -#include "paddle/phi/infermeta/binary.h" - -namespace paddle { -namespace operators { - -class TriangularSolveOp : public framework::OperatorWithKernel { - public: - using framework::OperatorWithKernel::OperatorWithKernel; - - phi::KernelKey GetExpectedKernelType( - const framework::ExecutionContext& ctx) const { - return phi::KernelKey(OperatorWithKernel::IndicateVarDataType(ctx, "X"), - ctx.GetPlace()); - } -}; - -class TriangularSolveOpMaker : public framework::OpProtoAndCheckerMaker { - public: - void Make() override { - AddInput("X", - "(Tensor), The first input tensor of triangular solve op, which " - "is the triangular coefficient matrix."); - AddInput("Y", - "(Tensor), The second input tensor of triangular solve op, which " - "is multiple right-hand."); - AddOutput("Out", "(Tensor), The solution tensor of triangular solve op."); - AddAttr("upper", - "whether to solve the upper-triangular or the " - "lower-triangular system of equations") - .SetDefault(true); - AddAttr("transpose", "whether X should be transposed firstly.") - .SetDefault(false); - AddAttr("unitriangular", "whether X is unit triangular.") - .SetDefault(false); - AddComment(R"DOC( - Triangular Solve Operator. - This operator is used to computes the solution of equations with a triangular coefficient matrix. - - The equation is: - $$Out = X^-1 * Y$$ -)DOC"); - } -}; - -class TriangularSolveOpInferVarType - : public framework::PassInDtypeAndVarTypeToOutput { - protected: - std::unordered_map& GetInputOutputWithSameType() - const override { - static std::unordered_map m{{"X", /*->*/ "Out"}}; - return m; - } -}; - -class TriangularSolveGradOp : public framework::OperatorWithKernel { - public: - using framework::OperatorWithKernel::OperatorWithKernel; - - void InferShape(framework::InferShapeContext* ctx) const override { - OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "triangular_solve"); - OP_INOUT_CHECK(ctx->HasInput("Y"), "Input", "Y", "triangular_solve"); - OP_INOUT_CHECK(ctx->HasInput("Out"), "Input", "Out", "triangular_solve"); - OP_INOUT_CHECK(ctx->HasInput(framework::GradVarName("Out")), - "Input", - "Out@GRAD", - "triangular_solve"); - - auto x_dims = ctx->GetInputDim("X"); - auto y_dims = ctx->GetInputDim("Y"); - - auto x_grad_name = framework::GradVarName("X"); - auto y_grad_name = framework::GradVarName("Y"); - - if (ctx->HasOutput(x_grad_name)) { - ctx->SetOutputDim(x_grad_name, x_dims); - } - if (ctx->HasOutput(y_grad_name)) { - ctx->SetOutputDim(y_grad_name, y_dims); - } - } -}; - -template -class TriangularSolveOpGradMaker : public framework::SingleGradOpMaker { - public: - using framework::SingleGradOpMaker::SingleGradOpMaker; - - protected: - void Apply(GradOpPtr retv) const override { - retv->SetType("triangular_solve_grad"); - retv->SetInput("X", this->Input("X")); - retv->SetInput("Y", this->Input("Y")); - retv->SetInput("Out", this->Output("Out")); - retv->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out")); - - retv->SetOutput(framework::GradVarName("X"), this->InputGrad("X")); - retv->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y")); - retv->SetAttrMap(this->Attrs()); - } -}; - -} // namespace operators -} // namespace paddle - -namespace ops = paddle::operators; - -DECLARE_INFER_SHAPE_FUNCTOR(triangular_solve, - TriangularSolveInferShapeFunctor, - PD_INFER_META(phi::TriangularSolveInferMeta)); - -REGISTER_OPERATOR(triangular_solve, - ops::TriangularSolveOp, - ops::TriangularSolveOpMaker, - ops::TriangularSolveOpInferVarType, - ops::TriangularSolveOpGradMaker, - ops::TriangularSolveOpGradMaker, - TriangularSolveInferShapeFunctor); - -REGISTER_OPERATOR(triangular_solve_grad, ops::TriangularSolveGradOp); diff --git a/paddle/phi/api/yaml/backward.yaml b/paddle/phi/api/yaml/backward.yaml index 9a31d8fb3e3b1adde5382638a8dfbace11c8aa34..a2189b7084bd27800e05c5e196dee5beb64f6672 100644 --- a/paddle/phi/api/yaml/backward.yaml +++ b/paddle/phi/api/yaml/backward.yaml @@ -1950,6 +1950,16 @@ data_type : out_grad no_need_buffer : x +- backward_op : triangular_solve_grad + forward : triangular_solve (Tensor x, Tensor y, bool upper=true, bool transpose=false, bool unitriangular=false) -> Tensor(out) + args : (Tensor x, Tensor y, Tensor out, Tensor out_grad, bool upper, bool transpose, bool unitriangular) + output : Tensor(x_grad), Tensor(y_grad) + infer_meta : + func : GeneralBinaryGradInferMeta + param : [x, y] + kernel : + func : triangular_solve_grad + - backward_op : trilinear_interp_grad forward : trilinear_interp (Tensor x, Tensor out_size, Tensor[] size_tensor, Tensor scale_tensor, str data_layout="NCHW", int out_d=0, int out_h=0, int out_w=0, float[] scale={}, str interp_method="bilinear", bool align_corners=true, int align_mode=1) -> Tensor(output) args : (Tensor x, Tensor out_size, Tensor[] size_tensor, Tensor scale_tensor, Tensor output_grad, str data_layout, int out_d, int out_h, int out_w, float[] scale, str interp_method, bool align_corners, int align_mode) diff --git a/paddle/phi/api/yaml/legacy_backward.yaml b/paddle/phi/api/yaml/legacy_backward.yaml index 590acb5b35b93086f6e26604ea81d3f1ddee07ab..30bfa1f38475894533674ce35d19fd710b6478d7 100755 --- a/paddle/phi/api/yaml/legacy_backward.yaml +++ b/paddle/phi/api/yaml/legacy_backward.yaml @@ -1034,16 +1034,6 @@ backward : transpose_double_grad composite: transpose_grad(out_grad, perm, x_grad) -- backward_op : triangular_solve_grad - forward : triangular_solve (Tensor x, Tensor y, bool upper, bool tranpose, bool unitriangular) -> Tensor(out) - args : (Tensor x, Tensor y, Tensor out, Tensor out_grad, bool upper, bool tranpose, bool unitriangular) - output : Tensor(x_grad), Tensor(y_grad) - infer_meta : - func : GeneralBinaryGradInferMeta - param : [x, y] - kernel : - func : triangular_solve_grad - - backward_op : tril_grad forward : tril(Tensor x, int diagonal) -> Tensor(out) args : (Tensor out_grad, int diagonal) diff --git a/paddle/phi/api/yaml/legacy_ops.yaml b/paddle/phi/api/yaml/legacy_ops.yaml index 257d67c3477eeec4d28cd9854812c33f3e11d4c7..c3610b4ae5ae1fcf1a9d61affeb36d3184c602cc 100755 --- a/paddle/phi/api/yaml/legacy_ops.yaml +++ b/paddle/phi/api/yaml/legacy_ops.yaml @@ -1140,16 +1140,6 @@ func : transpose backward : transpose_grad -- op : triangular_solve - args : (Tensor x, Tensor y, bool upper, bool transpose, bool unitriangular) - output : Tensor - infer_meta : - func : TriangularSolveInferMeta - kernel : - func : triangular_solve - data_type : x - backward : triangular_solve_grad - - op : tril args : (Tensor x, int diagonal) output : Tensor(out) diff --git a/paddle/phi/api/yaml/op_compat.yaml b/paddle/phi/api/yaml/op_compat.yaml index 17e56bd2a0e909ef5677511e33f934f5b0210f44..46245aa4c928e4f3d5f02e4e277f73cd3a6cca69 100755 --- a/paddle/phi/api/yaml/op_compat.yaml +++ b/paddle/phi/api/yaml/op_compat.yaml @@ -2334,6 +2334,13 @@ outputs : [XShape] attrs : [bool use_mkldnn = false, str data_format = "AnyLayout", str mkldnn_data_type = "float32"] +- op : triangular_solve + backward : triangular_solve_grad + inputs : + {x : X, y : Y} + outputs : + out : Out + - op : trilinear_interp (trilinear_interp_v2) backward : trilinear_interp_grad (trilinear_interp_v2_grad) inputs : diff --git a/paddle/phi/api/yaml/ops.yaml b/paddle/phi/api/yaml/ops.yaml index 8d99f741567365bfbceece851c20795d7fdcf6f1..bea41007e5aec3221305585d1b05cc3ca7539807 100644 --- a/paddle/phi/api/yaml/ops.yaml +++ b/paddle/phi/api/yaml/ops.yaml @@ -2062,6 +2062,16 @@ func : trace backward : trace_grad +- op : triangular_solve + args : (Tensor x, Tensor y, bool upper=true, bool transpose=false, bool unitriangular=false) + output : Tensor + infer_meta : + func : TriangularSolveInferMeta + kernel : + func : triangular_solve + data_type : x + backward : triangular_solve_grad + - op : trilinear_interp args : (Tensor x, Tensor out_size, Tensor[] size_tensor, Tensor scale_tensor, str data_layout="NCHW", int out_d=0, int out_h=0, int out_w=0, float[] scale={}, str interp_method="bilinear", bool align_corners=true, int align_mode=1) output : Tensor(output) diff --git a/paddle/phi/ops/compat/triangular_solve_sig.cc b/paddle/phi/ops/compat/triangular_solve_sig.cc deleted file mode 100644 index 851db32a032d65db0a4f5a724681861623ae894c..0000000000000000000000000000000000000000 --- a/paddle/phi/ops/compat/triangular_solve_sig.cc +++ /dev/null @@ -1,30 +0,0 @@ -// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "paddle/phi/core/compat/op_utils.h" - -namespace phi { - -KernelSignature TriangularSolveGradOpArgumentMapping( - const ArgumentMappingContext& ctx) { - return KernelSignature("triangular_solve_grad", - {"X", "Y", "Out", "Out@GRAD"}, - {"upper", "transpose", "unitriangular"}, - {"X@GRAD", "Y@GRAD"}); -} - -} // namespace phi - -PD_REGISTER_ARG_MAPPING_FN(triangular_solve_grad, - phi::TriangularSolveGradOpArgumentMapping);