support auto generate for op adagrad optimizer (#52695)

paddle/fluid/operators/optimizers/adagrad_op.cc

-/* Copyright (c) 2016 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 <cmath>
-#include <vector>
-
-#include "paddle/fluid/framework/infershape_utils.h"
-#include "paddle/fluid/framework/op_registry.h"
-#include "paddle/phi/core/infermeta_utils.h"
-#include "paddle/phi/infermeta/multiary.h"
-#include "paddle/phi/kernels/funcs/math_function.h"
-#include "paddle/phi/kernels/funcs/selected_rows_functor.h"
-
-namespace paddle {
-namespace operators {
-
-class AdagradOp : public framework::OperatorWithKernel {
- public:
-  using framework::OperatorWithKernel::OperatorWithKernel;
-
-  phi::KernelKey GetExpectedKernelType(
-      const framework::ExecutionContext& ctx) const override {
-    return phi::KernelKey(OperatorWithKernel::IndicateVarDataType(ctx, "Param"),
-                          ctx.GetPlace());
-  }
-};
-
-class AdagradOpMaker : public framework::OpProtoAndCheckerMaker {
- public:
-  void Make() override {
-    AddInput("Param", "(Tensor) Input parameter");
-    AddInput("Grad", "(Tensor) Input gradient");
-    AddInput("Moment", "(Tensor) Second moment");
-    AddInput("LearningRate", "(Tensor) Learning rate");
-    AddInput("MasterParam", "FP32 master weight for AMP.").AsDispensable();
-
-    AddOutput("ParamOut", "(Tensor) Output parameter");
-    AddOutput("MomentOut", "(Tensor) Output second moment");
-    AddOutput("MasterParamOut",
-              "The updated FP32 master weight for AMP. "
-              "It shared memory with Input(MasterParam).")
-        .AsDispensable();
-
-    AddAttr<float>("epsilon",
-                   "(float, default 1.0e-6) "
-                   "Constant for numerical stability")
-        .SetDefault(1.0e-6f);
-    AddAttr<bool>("multi_precision",
-                  "(bool, default false) "
-                  "Whether to use multi-precision during weight updating.")
-        .SetDefault(false);
-    AddComment(R"DOC(
-
-Adaptive Gradient Algorithm (Adagrad).
-
-The update is done as follows:
-
-$$moment\_out = moment + grad * grad \\
-param\_out = param - \frac{learning\_rate * grad}{\sqrt{moment\_out} + \epsilon}
-$$
-
-The original paper(http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf)
-does not have the epsilon attribute. It is added here in our implementation
-as also proposed here: http://cs231n.github.io/neural-networks-3/#ada
-for numerical stability to avoid the division by zero error.
-
-)DOC");
-  }
-};
-
-}  // namespace operators
-}  // namespace paddle
-
-namespace ops = paddle::operators;
-DECLARE_INFER_SHAPE_FUNCTOR(adagrad,
-                            AdagradInferShapeFunctor,
-                            PD_INFER_META(phi::AdagradInferMeta));
-REGISTER_OP_WITHOUT_GRADIENT(adagrad,
-                             ops::AdagradOp,
-                             ops::AdagradOpMaker,
-                             AdagradInferShapeFunctor);

paddle/fluid/operators/optimizers/unity_build_rule.cmake

@@ -9,7 +9,6 @@ register_unity_group(
   ftrl_op.cc
   lars_momentum_op.cc
   proximal_adagrad_op.cc
-  adagrad_op.cc
   adam_op.cc
   adamax_op.cc
   dgc_momentum_op.cc

paddle/phi/api/yaml/legacy_ops.yaml

@@ -21,18 +21,6 @@
   optional : master_param
   inplace : (param -> param_out), (avg_squared_grad -> moment_out), (avg_squared_update -> inf_norm_out), (master_param -> master_param_out)
 
-- op : adagrad_
-  args : (Tensor param, Tensor grad, Tensor moment, Tensor learning_rate, Tensor master_param, float epsilon, bool multi_precision)
-  output : Tensor(param_out), Tensor(moment_out), Tensor(master_param_out)
-  infer_meta :
-    func : AdagradInferMeta
-  kernel :
-    func : adagrad {dense, dense, dense, dense, dense -> dense, dense, dense}
-           adagrad_dense_param_sparse_grad {dense, selected_rows, dense, dense, dense-> dense, dense, dense}
-    data_type : param
-  optional : master_param
-  inplace : (param -> param_out), (moment -> moment_out), (master_param -> master_param_out)
-
 - op : adam_
   args : (Tensor param, Tensor grad, Tensor learning_rate, Tensor moment1, Tensor moment2, Tensor beta1_pow, Tensor beta2_pow, Tensor master_param, Tensor skip_update, Scalar beta1, Scalar beta2, Scalar epsilon, bool lazy_mode, int64_t min_row_size_to_use_multithread, bool multi_precision, bool use_global_beta_pow)
   output : Tensor(param_out), Tensor(moment1_out), Tensor(moment2_out), Tensor(beta1_pow_out), Tensor(beta2_pow_out), Tensor(master_param_outs)

paddle/phi/api/yaml/op_compat.yaml

@@ -44,6 +44,12 @@
   extra :
     attrs : [bool use_mkldnn = false, bool use_cudnn = false]
 
+- op : adagrad_
+  inputs :
+    { param : Param, grad : Grad, moment : Moment, learning_rate : LearningRate, master_param : MasterParam }
+  outputs :
+    { param_out : ParamOut, moment_out : MomentOut, master_param_out : MasterParamOut }
+
 - op : add (elementwise_add)
   backward : add_grad (elementwise_add_grad)
   extra :

paddle/phi/api/yaml/ops.yaml

@@ -32,6 +32,18 @@
     func : acosh
   backward : acosh_grad
 
+- op : adagrad_
+  args : (Tensor param, Tensor grad, Tensor moment, Tensor learning_rate, Tensor master_param, float epsilon = 1.0e-6f, bool multi_precision = false)
+  output : Tensor(param_out), Tensor(moment_out), Tensor(master_param_out)
+  infer_meta :
+    func : AdagradInferMeta
+  kernel :
+    func : adagrad {dense, dense, dense, dense, dense -> dense, dense, dense}
+           adagrad_dense_param_sparse_grad {dense, selected_rows, dense, dense, dense -> dense, dense, dense}
+    data_type : param
+  optional : master_param, master_param_out
+  inplace : (param -> param_out), (moment -> moment_out), (master_param -> master_param_out)
+
 - op : addmm
   args : (Tensor input, Tensor x, Tensor y, float beta=1.0, float alpha=1.0)
   output : Tensor

paddle/phi/ops/compat/adagrad_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 AdagradOpArgumentMapping(const ArgumentMappingContext& ctx) {
-  if (ctx.IsDenseTensorInput("Grad")) {
-    return KernelSignature(
-        "adagrad",
-        {"Param", "Grad", "Moment", "LearningRate", "MasterParam"},
-        {"epsilon", "multi_precision"},
-        {"ParamOut", "MomentOut", "MasterParamOut"});
-  } else if (ctx.IsSelectedRowsInput("Grad")) {
-    return KernelSignature(
-        "adagrad_dense_param_sparse_grad",
-        {"Param", "Grad", "Moment", "LearningRate", "MasterParam"},
-        {"epsilon", "multi_precision"},
-        {"ParamOut", "MomentOut", "MasterParamOut"});
-  }
-
-  return KernelSignature("unregistered", {}, {}, {});
-}
-
-}  // namespace phi
-
-PD_REGISTER_ARG_MAPPING_FN(adagrad, phi::AdagradOpArgumentMapping);