support auto generate for bce_loss (#52231)

* bce_loss

* fix error

* fix

* fix

* fix

* reslove confilict

paddle/fluid/operators/bce_loss_op.cc

-/* Copyright (c) 2020 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 <memory>
-#include <string>
-#include <vector>
-
-#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 BCELossOp : public framework::OperatorWithKernel {
- public:
-  using framework::OperatorWithKernel::OperatorWithKernel;
-
- protected:
-  phi::KernelKey GetExpectedKernelType(
-      const framework::ExecutionContext& ctx) const override {
-    return phi::KernelKey(OperatorWithKernel::IndicateVarDataType(ctx, "X"),
-                          ctx.device_context().GetPlace());
-  }
-};
-
-class BCELossGradOp : public framework::OperatorWithKernel {
- public:
-  using framework::OperatorWithKernel::OperatorWithKernel;
-
-  void InferShape(framework::InferShapeContext* ctx) const override {
-    OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "BCELossGrad");
-    OP_INOUT_CHECK(ctx->HasInput("Label"), "Input", "Label", "BCELossGrad");
-    OP_INOUT_CHECK(ctx->HasInput(framework::GradVarName("Out")),
-                   "Input",
-                   framework::GradVarName("Out"),
-                   "BCELossGrad");
-    OP_INOUT_CHECK(ctx->HasOutput(framework::GradVarName("X")),
-                   "Output",
-                   framework::GradVarName("X"),
-                   "BCELossGrad");
-
-    auto x_dims = ctx->GetInputDim("X");
-    auto labels_dims = ctx->GetInputDim("Label");
-    auto dout_dims = ctx->GetInputDim(framework::GradVarName("Out"));
-
-    bool check = true;
-    if ((!ctx->IsRuntime()) &&
-        (phi::product(x_dims) <= 0 || phi::product(labels_dims) <= 0)) {
-      check = false;
-    }
-
-    if (check) {
-      PADDLE_ENFORCE_EQ(x_dims,
-                        labels_dims,
-                        platform::errors::InvalidArgument(
-                            "Input(X) and Input(Label) shall have the same "
-                            "shape. But received: the shape of Input(X) is "
-                            "[%s], the shape of Input(Label) is [%s].",
-                            x_dims,
-                            labels_dims));
-
-      PADDLE_ENFORCE_EQ(x_dims,
-                        dout_dims,
-                        platform::errors::InvalidArgument(
-                            "Input(X) and Input(Out@Grad) shall have the same "
-                            "shape. But received: the shape of Input(X) is "
-                            "[%s], the shape of Input(Out@Grad) is [%s].",
-                            x_dims,
-                            dout_dims));
-    }
-
-    ctx->SetOutputDim(framework::GradVarName("X"), x_dims);
-    ctx->ShareLoD("X", framework::GradVarName("X"));
-  }
-
- protected:
-  phi::KernelKey GetExpectedKernelType(
-      const framework::ExecutionContext& ctx) const override {
-    return phi::KernelKey(OperatorWithKernel::IndicateVarDataType(ctx, "X"),
-                          ctx.device_context().GetPlace());
-  }
-};
-
-class BCELossOpMaker : public framework::OpProtoAndCheckerMaker {
- public:
-  void Make() override {
-    AddInput("X",
-             "(Tensor, default Tensor<float>), the input is a tensor of logits"
-             "computed by the previous operator, which is always the result of"
-             "a sigmoid operator. Input must between in 0 and 1.");
-    AddInput("Label",
-             "(Tensor, default Tensor<float>), have same shape with input"
-             "label should between in 0 and 1.");
-    AddOutput("Out",
-              "(Tensor, default Tensor<float>), have same shape with"
-              "input");
-    AddComment(R"DOC(
-BinaryCrossEntropy operator.
-
-This measures the element-wise probability error in classification tasks
-in which each class is independent.
-
-The logitstic loss is given as follows:
-      $$loss = -Label * \log(X) - (1 - Label) * \log(1 - X)$$
-)DOC");
-  }
-};
-
-template <typename T>
-class BCELossGradOpMaker : public framework::SingleGradOpMaker<T> {
- public:
-  using framework::SingleGradOpMaker<T>::SingleGradOpMaker;
-
- protected:
-  void Apply(GradOpPtr<T> op) const override {
-    op->SetType("bce_loss_grad");
-    op->SetInput("X", this->Input("X"));
-    op->SetInput("Label", this->Input("Label"));
-    op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out"));
-    op->SetOutput(framework::GradVarName("X"), this->InputGrad("X"));
-  }
-};
-
-DECLARE_INPLACE_OP_INFERER(BCELossInplaceInferer, {"X", "Out"});
-DECLARE_INPLACE_OP_INFERER(BCELossGradInplaceInferer,
-                           {framework::GradVarName("Out"),
-                            framework::GradVarName("X")});
-
-}  // namespace operators
-}  // namespace paddle
-
-namespace ops = paddle::operators;
-DECLARE_INFER_SHAPE_FUNCTOR(bce_loss,
-                            BCELossInferShapeFunctor,
-                            PD_INFER_META(phi::BCELossInferMeta));
-
-REGISTER_OPERATOR(bce_loss,
-                  ops::BCELossOp,
-                  ops::BCELossOpMaker,
-                  ops::BCELossGradOpMaker<paddle::framework::OpDesc>,
-                  ops::BCELossGradOpMaker<paddle::imperative::OpBase>,
-                  ops::BCELossInplaceInferer,
-                  BCELossInferShapeFunctor);
-REGISTER_OPERATOR(bce_loss_grad,
-                  ops::BCELossGradOp,
-                  ops::BCELossGradInplaceInferer);

paddle/phi/api/yaml/backward.yaml

@@ -121,6 +121,17 @@
     func : atanh_grad
   inplace : (out_grad -> x_grad)
 
+- backward_op : bce_loss_grad
+  forward : bce_loss (Tensor input, Tensor label) -> Tensor(out)
+  args : (Tensor input, Tensor label, Tensor out_grad)
+  output : Tensor(input_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [input]
+  kernel :
+    func : bce_loss_grad
+  inplace : (out_grad -> input_grad)
+
 - backward_op : bicubic_interp_grad
   forward : bicubic_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)

paddle/phi/api/yaml/legacy_backward.yaml

@@ -134,17 +134,6 @@
   composite: batch_norm_grad(x, scale, bias, mean_out, variance_out, saved_mean, saved_variance, reserve_space, out_grad, momentum, epsilon, data_layout, is_test, use_global_stats, trainable_statistics)
   backward : batch_norm_double_grad
 
-- backward_op : bce_loss_grad
-  forward : bce_loss (Tensor input, Tensor label) -> Tensor(out)
-  args : (Tensor input, Tensor label, Tensor out_grad)
-  output : Tensor(input_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [input]
-  kernel :
-    func : bce_loss_grad
-  inplace : (out_grad -> input_grad)
-
 - backward_op : bilinear_tensor_product_grad
   forward : bilinear_tensor_product (Tensor x, Tensor y, Tensor weight, Tensor bias) -> Tensor(out)
   args : (Tensor x, Tensor y, Tensor weight, Tensor out_grad)

paddle/phi/api/yaml/legacy_ops.yaml

@@ -214,15 +214,6 @@
   view : (mean -> mean_out), (variance -> variance_out)
   backward : batch_norm_grad
 
-- op : bce_loss
-  args : (Tensor input, Tensor label)
-  output : Tensor
-  infer_meta :
-    func : BCELossInferMeta
-  kernel :
-    func : bce_loss
-  backward : bce_loss_grad
-
 - op : bilinear_tensor_product
   args : (Tensor x, Tensor y, Tensor weight, Tensor bias)
   output : Tensor

paddle/phi/api/yaml/op_compat.yaml

@@ -198,6 +198,13 @@
   extra :
     attrs : [bool use_mkldnn = false, bool fuse_with_relu = false]
 
+- op : bce_loss
+  backward : bce_loss_grad
+  inputs :
+    {input : X, label : Label}
+  outputs :
+    out : Out
+
 - op : bernoulli
   inputs :
     x : X

paddle/phi/api/yaml/ops.yaml

@@ -143,6 +143,17 @@
     data_type : x
   optional : ins_tag_weight
 
+- op : bce_loss
+  args : (Tensor input, Tensor label)
+  output : Tensor
+  infer_meta :
+    func : BCELossInferMeta
+  kernel :
+    func : bce_loss
+    data_type : input
+  inplace : (input -> out)
+  backward : bce_loss_grad
+
 - op : bernoulli
   args : (Tensor x)
   output : Tensor(out)

paddle/phi/ops/compat/bce_loss_sig.cc

-// 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 BCELossGradOpArgumentMapping(
-    const ArgumentMappingContext& ctx) {
-  return KernelSignature(
-      "bce_loss_grad", {"X", "Label", "Out@GRAD"}, {}, {"X@GRAD"});
-}
-
-}  // namespace phi
-
-PD_REGISTER_ARG_MAPPING_FN(bce_loss_grad, phi::BCELossGradOpArgumentMapping);