diff --git a/paddle/fluid/operators/fused/fused_dropout_test.h b/paddle/fluid/operators/fused/fused_dropout_test.h
index b71ed39c682514d6e69cc1de934367c4d5ed9f76..a985d23b483a71aacb166b5e509b18ee5bb7da3a 100644
--- a/paddle/fluid/operators/fused/fused_dropout_test.h
+++ b/paddle/fluid/operators/fused/fused_dropout_test.h
@@ -193,7 +193,6 @@ void LayerNorm(const std::vector<LayerNormParamType<T>> &scale,
                           bias_opt,
                           1e-5,
                           1,
-                          false,
                           tensor_y,
                           tensor_mean,
                           tensor_variance);
diff --git a/paddle/fluid/operators/tril_triu_op.cc b/paddle/fluid/operators/tril_triu_op.cc
index 97c9289295022b8cbbe7afa92f38b3c1eada060c..5d2c3c0797acf2106cfb47b06b11eb54c3cff72a 100644
--- a/paddle/fluid/operators/tril_triu_op.cc
+++ b/paddle/fluid/operators/tril_triu_op.cc
@@ -93,7 +93,7 @@ namespace ops = paddle::operators;
 namespace plat = paddle::platform;
 DECLARE_INFER_SHAPE_FUNCTOR(tril_triu,
                             TrilTriuInferShapeFunctor,
-                            PD_INFER_META(phi::TrilInferMeta));
+                            PD_INFER_META(phi::TrilTriuInferMeta));
 REGISTER_OPERATOR(tril_triu,
                   ops::TrilTriuOp,
                   ops::TrilTriuOpMaker,
diff --git a/paddle/phi/api/yaml/legacy_backward.yaml b/paddle/phi/api/yaml/legacy_backward.yaml
index f920bbb8b23a7db7ad5036d14fe4dff44f3034f4..a61aa52cc821f269b4f11a58bb19a6144601c1ce 100755
--- a/paddle/phi/api/yaml/legacy_backward.yaml
+++ b/paddle/phi/api/yaml/legacy_backward.yaml
@@ -655,8 +655,8 @@
   inplace : (out_grad -> x_grad)
 
 - backward_op : hsigmoid_loss_grad
-  forward : hsigmoid_loss (Tensor x, Tensor w, Tensor label, Tensor path, Tensor code, Tensor bias, int num_classes, bool remote_prefetch, int trainer_id, int64_t[] height_sections, str[] epmap, str[] table_names, bool is_sparse) -> Tensor(out), Tensor(pre_out), Tensor(w_out)
-  args : (Tensor x, Tensor w, Tensor label, Tensor path, Tensor code, Tensor bias, Tensor pre_out, Tensor out_grad, int num_classes, bool remote_prefetch, int trainer_id, int64_t[] height_sections, str[] epmap, str[] table_names, bool is_sparse)
+  forward : hsigmoid_loss (Tensor x, Tensor label, Tensor w, Tensor bias, Tensor path, Tensor code, int num_classes, bool remote_prefetch, bool is_sparse) -> Tensor(out), Tensor(pre_out), Tensor(w_out)
+  args : (Tensor x, Tensor w, Tensor label, Tensor path, Tensor code, Tensor bias, Tensor pre_out, Tensor out_grad, int num_classes, bool remote_prefetch, bool is_sparse)
   output : Tensor(x_grad), Tensor(w_grad), Tensor(bias_grad)
   infer_meta :
     func : GeneralTernaryGradInferMeta
@@ -764,8 +764,8 @@
     func : label_smooth_grad
 
 - backward_op : layer_norm_grad
-  forward : layer_norm (Tensor x, Tensor scale, Tensor bias, float epsilon, int begin_norm_axis, bool is_test) -> Tensor(out), Tensor(mean), Tensor(variance)
-  args : (Tensor x,  Tensor scale, Tensor bias, Tensor mean, Tensor variance, Tensor out_grad, float epsilon, int begin_norm_axis, bool is_test)
+  forward : layer_norm (Tensor x, Tensor scale, Tensor bias, float epsilon, int begin_norm_axis) -> Tensor(out), Tensor(mean), Tensor(variance)
+  args : (Tensor x,  Tensor scale, Tensor bias, Tensor mean, Tensor variance, Tensor out_grad, float epsilon, int begin_norm_axis)
   output : Tensor(x_grad), Tensor(scale_grad), Tensor(bias_grad)
   infer_meta :
     func : LayerNormGradInferMeta
@@ -1830,8 +1830,8 @@
     func : triangular_solve_grad
 
 - backward_op : tril_grad
-  forward : tril(Tensor x,  int diagonal,  bool lower) -> Tensor(out)
-  args : (Tensor out_grad,  int diagonal,  bool lower)
+  forward : tril(Tensor x,  int diagonal) -> Tensor(out)
+  args : (Tensor out_grad,  int diagonal)
   output : Tensor(x_grad)
   infer_meta :
     func : UnchangedInferMeta
@@ -1851,6 +1851,16 @@
     func : trilinear_interp_grad
     data_type : output_grad
 
+- backward_op : triu_grad
+  forward : triu(Tensor x,  int diagonal) -> Tensor(out)
+  args : (Tensor out_grad,  int diagonal)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out_grad]
+  kernel :
+    func : triu_grad
+
 - backward_op : unbind_grad
   forward : unbind (Tensor input, int axis) -> Tensor[](out)
   args : (Tensor[] out_grad, int axis)
diff --git a/paddle/phi/api/yaml/legacy_ops.yaml b/paddle/phi/api/yaml/legacy_ops.yaml
index a1bc49a477ac3f478645c69b5176f3cd3190f5ae..7fb2c2441055ed0a5b846921f7c71adf498ad68a 100755
--- a/paddle/phi/api/yaml/legacy_ops.yaml
+++ b/paddle/phi/api/yaml/legacy_ops.yaml
@@ -934,7 +934,7 @@
   backward : hardtanh_grad
 
 - op : hsigmoid_loss
-  args : (Tensor x, Tensor w, Tensor label, Tensor path, Tensor code, Tensor bias, int num_classes, bool remote_prefetch, int trainer_id, int64_t[] height_sections, str[] epmap, str[] table_names, bool is_sparse)
+  args : (Tensor x, Tensor label, Tensor w, Tensor bias, Tensor path, Tensor code, int num_classes, bool remote_prefetch, bool is_sparse)
   output : Tensor(out), Tensor(pre_out), Tensor(w_out)
   infer_meta :
     func : HSigmoidLossInferMeta
@@ -1091,7 +1091,7 @@
   inplace : (param -> param_out), (moment1 -> moment1_out), (moment2 -> moment2_out), (beta1_pow -> beta1_pow_out), (beta2_pow -> beta2_pow_out), (master_param -> master_param_outs)
 
 - op : layer_norm
-  args : (Tensor x, Tensor scale, Tensor bias, float epsilon, int begin_norm_axis, bool is_test)
+  args : (Tensor x, Tensor scale, Tensor bias, float epsilon, int begin_norm_axis)
   output : Tensor(out), Tensor(mean), Tensor(variance)
   infer_meta :
     func : LayerNormInferMeta
@@ -1294,11 +1294,11 @@
   backward : matrix_power_grad
 
 - op : matrix_rank
-  args : (Tensor x, float tol, bool use_default_tol=true, bool hermitian=false)
+  args : (Tensor x, float tol, bool hermitian=false, bool use_default_tol=true)
   output : Tensor(out)
   infer_meta :
     func : MatrixRankInferMeta
-    param : [x, use_default_tol, hermitian]
+    param : [x, hermitian, use_default_tol]
   kernel :
     func : matrix_rank
 
@@ -2226,7 +2226,7 @@
   backward : triangular_solve_grad
 
 - op : tril
-  args : (Tensor x,  int diagonal,  bool lower)
+  args : (Tensor x,  int diagonal)
   output : Tensor(out)
   infer_meta :
     func : TrilInferMeta
@@ -2257,6 +2257,15 @@
     data_type : x
   backward : trilinear_interp_grad
 
+- op : triu
+  args : (Tensor x,  int diagonal)
+  output : Tensor(out)
+  infer_meta :
+    func : TriuInferMeta
+  kernel :
+    func : triu
+  backward : triu_grad
+
 - op : triu_indices
   args : (int row, int col, int offset, DataType dtype, Place place={})
   output : Tensor(out)
diff --git a/paddle/phi/infermeta/multiary.cc b/paddle/phi/infermeta/multiary.cc
index b9e84c2df57141108fd619162cf87ad71e89ef59..29c2436c8e8c0b6dd098a8dffd11bf0bc64f747b 100644
--- a/paddle/phi/infermeta/multiary.cc
+++ b/paddle/phi/infermeta/multiary.cc
@@ -1330,17 +1330,13 @@ void GraphSampleNeighborsInferMeta(const MetaTensor& row,
 }
 
 void HSigmoidLossInferMeta(const MetaTensor& x,
-                           const MetaTensor& w,
                            const MetaTensor& label,
+                           const MetaTensor& w,
+                           const MetaTensor& bias,
                            const MetaTensor& path,
                            const MetaTensor& code,
-                           const MetaTensor& bias,
                            int num_classes,
                            bool remote_prefetch,
-                           int trainer_id,
-                           const std::vector<int64_t>& height_sections,
-                           const std::vector<std::string>& epmap,
-                           const std::vector<std::string>& table_names,
                            bool is_sparse,
                            MetaTensor* out,
                            MetaTensor* pre_out,
diff --git a/paddle/phi/infermeta/multiary.h b/paddle/phi/infermeta/multiary.h
index a37925202926a7ab28e317b6cc0e8fb2559122a8..3607097400a39168e192a88f2b63792691472e13 100644
--- a/paddle/phi/infermeta/multiary.h
+++ b/paddle/phi/infermeta/multiary.h
@@ -288,17 +288,13 @@ void GraphSampleNeighborsInferMeta(const MetaTensor& row,
                                    MetaTensor* out_eids);
 
 void HSigmoidLossInferMeta(const MetaTensor& x,
-                           const MetaTensor& w,
                            const MetaTensor& label,
+                           const MetaTensor& w,
+                           const MetaTensor& bias,
                            const MetaTensor& path,
                            const MetaTensor& code,
-                           const MetaTensor& bias,
                            int num_classes,
                            bool remote_prefetch,
-                           int trainer_id,
-                           const std::vector<int64_t>& height_sections,
-                           const std::vector<std::string>& epmap,
-                           const std::vector<std::string>& table_names,
                            bool is_sparse,
                            MetaTensor* out,
                            MetaTensor* pre_out,
diff --git a/paddle/phi/infermeta/ternary.cc b/paddle/phi/infermeta/ternary.cc
index 9b3ffbd08376294f249f867ff800b987d7ae1114..1b945c0254fb38405eff619211fa610f5e3ea0ab 100644
--- a/paddle/phi/infermeta/ternary.cc
+++ b/paddle/phi/infermeta/ternary.cc
@@ -498,7 +498,6 @@ void LayerNormInferMeta(const MetaTensor& x,
                         const MetaTensor& bias,
                         float epsilon,
                         int begin_norm_axis,
-                        bool is_test,
                         MetaTensor* out,
                         MetaTensor* mean,
                         MetaTensor* variance,
diff --git a/paddle/phi/infermeta/ternary.h b/paddle/phi/infermeta/ternary.h
index 1d0e7e8744dc1c0aece98b1251069f8d6d233bf1..7f24f2970095b46218a917612305d6ed9f6f4faf 100644
--- a/paddle/phi/infermeta/ternary.h
+++ b/paddle/phi/infermeta/ternary.h
@@ -87,7 +87,6 @@ void LayerNormInferMeta(const MetaTensor& x,
                         const MetaTensor& bias,
                         float epsilon,
                         int begin_norm_axis,
-                        bool is_test,
                         MetaTensor* out,
                         MetaTensor* mean,
                         MetaTensor* variance,
diff --git a/paddle/phi/infermeta/unary.cc b/paddle/phi/infermeta/unary.cc
index f51a4a2b2b9de1b3cedfe85948ad6345fe8a9947..a3da5aca24e11695fdb9fffa7de3755219a21b5d 100644
--- a/paddle/phi/infermeta/unary.cc
+++ b/paddle/phi/infermeta/unary.cc
@@ -1882,8 +1882,8 @@ void LUInferMeta(const MetaTensor& x,
 }
 
 void MatrixRankInferMeta(const MetaTensor& x,
-                         bool use_default_tol,
                          bool hermitian,
+                         bool use_default_tol,
                          MetaTensor* out) {
   auto dim_x = x.dims();
   PADDLE_ENFORCE_GE(dim_x.size(),
@@ -4156,10 +4156,10 @@ void UnbindInferMeta(const MetaTensor& x,
   }
 }
 
-void TrilInferMeta(const MetaTensor& x,
-                   int diagonal,
-                   bool lower,
-                   MetaTensor* out) {
+void TrilTriuInferMeta(const MetaTensor& x,
+                       int diagonal,
+                       bool lower,
+                       MetaTensor* out) {
   const auto& x_dims = x.dims();
   PADDLE_ENFORCE_GE(x_dims.size(),
                     2,
@@ -4170,6 +4170,14 @@ void TrilInferMeta(const MetaTensor& x,
   out->set_dtype(x.dtype());
 }
 
+void TrilInferMeta(const MetaTensor& x, int diagonal, MetaTensor* out) {
+  TrilTriuInferMeta(x, diagonal, true, out);
+}
+
+void TriuInferMeta(const MetaTensor& x, int diagonal, MetaTensor* out) {
+  TrilTriuInferMeta(x, diagonal, false, out);
+}
+
 void UnchangedInferMeta(const MetaTensor& x, MetaTensor* out) {
   out->share_meta(x);
 }
diff --git a/paddle/phi/infermeta/unary.h b/paddle/phi/infermeta/unary.h
index 153b2b8f5f2179515c730398c7ad38035796ab33..c7b7780b0cbee62cfdae69badc41d149a6dc49a2 100644
--- a/paddle/phi/infermeta/unary.h
+++ b/paddle/phi/infermeta/unary.h
@@ -264,8 +264,8 @@ void LUInferMeta(const MetaTensor& x,
 void MatrixPowerInferMeta(const MetaTensor& x, int n, MetaTensor* out);
 
 void MatrixRankInferMeta(const MetaTensor& x,
-                         bool use_default_tol,
                          bool hermitian,
+                         bool use_default_tol,
                          MetaTensor* out);
 
 void MaxOutInferMeta(const MetaTensor& x,
@@ -601,10 +601,14 @@ void TransposeGradInferMeta(const MetaTensor& x,
                             const std::vector<int>& axis,
                             MetaTensor* out);
 
-void TrilInferMeta(const MetaTensor& x,
-                   int diagonal,
-                   bool lower,
-                   MetaTensor* out);
+void TrilInferMeta(const MetaTensor& x, int diagonal, MetaTensor* out);
+
+void TriuInferMeta(const MetaTensor& x, int diagonal, MetaTensor* out);
+
+void TrilTriuInferMeta(const MetaTensor& x,
+                       int diagonal,
+                       bool lower,
+                       MetaTensor* out);
 
 void UnbindInferMeta(const MetaTensor& x,
                      int axis,
diff --git a/paddle/phi/kernels/cpu/hsigmoid_loss_grad.h b/paddle/phi/kernels/cpu/hsigmoid_loss_grad.h
index 7e6693c4dd7a1a6adb19df68ccffb6e0e0fdbb36..12960e305a0c69e3f6defb51992f027a5b14f357 100644
--- a/paddle/phi/kernels/cpu/hsigmoid_loss_grad.h
+++ b/paddle/phi/kernels/cpu/hsigmoid_loss_grad.h
@@ -37,10 +37,6 @@ void HSigmoidLossGradKernelImpl(const Context& ctx,
                                 const DenseTensor& out_grad,
                                 int num_classes,
                                 bool remote_prefetch,
-                                int trainer_id,
-                                const std::vector<int64_t>& height_sections,
-                                const std::vector<std::string>& epmap,
-                                const std::vector<std::string>& table_names,
                                 bool is_sparse,
                                 DenseTensor* x_grad,
                                 DenseTensor* w_grad,
diff --git a/paddle/phi/kernels/cpu/hsigmoid_loss_grad_kernel.cc b/paddle/phi/kernels/cpu/hsigmoid_loss_grad_kernel.cc
index efb59d1f4826730ece2c034d21a7c84c7f992061..bc741b32b3afc9e2eb013130db6b418118e1f800 100644
--- a/paddle/phi/kernels/cpu/hsigmoid_loss_grad_kernel.cc
+++ b/paddle/phi/kernels/cpu/hsigmoid_loss_grad_kernel.cc
@@ -32,10 +32,6 @@ void HSigmoidLossGradKernel(const Context& ctx,
                             const DenseTensor& out_grad,
                             int num_classes,
                             bool remote_prefetch,
-                            int trainer_id,
-                            const std::vector<int64_t>& height_sections,
-                            const std::vector<std::string>& epmap,
-                            const std::vector<std::string>& table_names,
                             bool is_sparse,
                             DenseTensor* x_grad,
                             DenseTensor* w_grad,
@@ -51,10 +47,6 @@ void HSigmoidLossGradKernel(const Context& ctx,
                                 out_grad,
                                 num_classes,
                                 remote_prefetch,
-                                trainer_id,
-                                height_sections,
-                                epmap,
-                                table_names,
                                 is_sparse,
                                 x_grad,
                                 w_grad,
diff --git a/paddle/phi/kernels/cpu/hsigmoid_loss_kernel.cc b/paddle/phi/kernels/cpu/hsigmoid_loss_kernel.cc
index fa0c83031d90435b502682933deb093c5545e804..a6f10b4ff13b4aee63ff8561f1b433107e4aa816 100644
--- a/paddle/phi/kernels/cpu/hsigmoid_loss_kernel.cc
+++ b/paddle/phi/kernels/cpu/hsigmoid_loss_kernel.cc
@@ -30,17 +30,13 @@ namespace math = paddle::operators::math;
 template <typename T, typename Context>
 void HSigmoidLossKernel(const Context& ctx,
                         const DenseTensor& x,
-                        const DenseTensor& w,
                         const DenseTensor& label,
+                        const DenseTensor& w,
+                        const paddle::optional<DenseTensor>& bias,
                         const paddle::optional<DenseTensor>& path,
                         const paddle::optional<DenseTensor>& code,
-                        const paddle::optional<DenseTensor>& bias,
                         int num_classes,
                         bool remote_prefetch,
-                        int trainer_id,
-                        const std::vector<int64_t>& height_sections,
-                        const std::vector<std::string>& epmap,
-                        const std::vector<std::string>& table_names,
                         bool is_sparse,
                         DenseTensor* out,
                         DenseTensor* pre_out,
diff --git a/paddle/phi/kernels/cpu/layer_norm_grad_kernel.cc b/paddle/phi/kernels/cpu/layer_norm_grad_kernel.cc
index 58d69cb3454e7577d391e6dcf7bcab1f4afea9be..fb61ced9f4326d8289ff4f5a11803676bd80d49a 100644
--- a/paddle/phi/kernels/cpu/layer_norm_grad_kernel.cc
+++ b/paddle/phi/kernels/cpu/layer_norm_grad_kernel.cc
@@ -40,7 +40,6 @@ void LayerNormGradKernel(const Context& dev_ctx,
                          const DenseTensor& out_grad,
                          float epsilon,
                          int begin_norm_axis,
-                         bool is_test,
                          DenseTensor* x_grad,
                          DenseTensor* scale_grad,
                          DenseTensor* bias_grad) {
diff --git a/paddle/phi/kernels/cpu/layer_norm_kernel.cc b/paddle/phi/kernels/cpu/layer_norm_kernel.cc
index 7061d4f0ad7303f17e69ebf5808d1cf9cd4b7a7d..542f19c83b2747d2bf3d27c005bf16474ca2411a 100644
--- a/paddle/phi/kernels/cpu/layer_norm_kernel.cc
+++ b/paddle/phi/kernels/cpu/layer_norm_kernel.cc
@@ -35,7 +35,6 @@ void LayerNormKernel(const Context& dev_ctx,
                      const paddle::optional<DenseTensor>& bias_opt,
                      float epsilon,
                      int begin_norm_axis,
-                     bool is_test,
                      DenseTensor* y,
                      DenseTensor* mean,
                      DenseTensor* var) {
diff --git a/paddle/phi/kernels/cpu/matrix_rank_kernel.cc b/paddle/phi/kernels/cpu/matrix_rank_kernel.cc
index f56bd3d6dbe8aad653dcc94e974ef6a857f6f398..9c23ead1e68daa653ec1517e9f0d38fec093ac17 100644
--- a/paddle/phi/kernels/cpu/matrix_rank_kernel.cc
+++ b/paddle/phi/kernels/cpu/matrix_rank_kernel.cc
@@ -24,8 +24,8 @@ template <typename T, typename Context>
 void MatrixRankKernel(const Context& dev_ctx,
                       const DenseTensor& x,
                       float tol,
-                      bool use_default_tol,
                       bool hermitian,
+                      bool use_default_tol,
                       DenseTensor* out) {
   DenseTensor atol_tensor;
   if (use_default_tol) {
diff --git a/paddle/phi/kernels/cpu/tril_grad_kernel.cc b/paddle/phi/kernels/cpu/tril_triu_grad_kernel.cc
similarity index 60%
rename from paddle/phi/kernels/cpu/tril_grad_kernel.cc
rename to paddle/phi/kernels/cpu/tril_triu_grad_kernel.cc
index fba457424fc052fc6ccd0754fdf3e23e048343ab..83600f7fd6df62eb6c470ff6676dfed97301a506 100644
--- a/paddle/phi/kernels/cpu/tril_grad_kernel.cc
+++ b/paddle/phi/kernels/cpu/tril_triu_grad_kernel.cc
@@ -14,7 +14,29 @@
 
 #include "paddle/phi/backends/cpu/cpu_context.h"
 #include "paddle/phi/core/kernel_registry.h"
-#include "paddle/phi/kernels/impl/tril_grad_kernel_impl.h"
+#include "paddle/phi/kernels/impl/tril_triu_grad_kernel_impl.h"
+
+PD_REGISTER_KERNEL(tril_triu_grad,
+                   CPU,
+                   ALL_LAYOUT,
+                   phi::TrilTriuGradKernel,
+                   bool,
+                   float,
+                   double,
+                   int,
+                   int64_t,
+                   phi::dtype::float16) {}
+
+PD_REGISTER_KERNEL(triu_grad,
+                   CPU,
+                   ALL_LAYOUT,
+                   phi::TriuGradKernel,
+                   bool,
+                   float,
+                   double,
+                   int,
+                   int64_t,
+                   phi::dtype::float16) {}
 
 PD_REGISTER_KERNEL(tril_grad,
                    CPU,
diff --git a/paddle/phi/kernels/cpu/tril_kernel.cc b/paddle/phi/kernels/cpu/tril_triu_kernel.cc
similarity index 60%
rename from paddle/phi/kernels/cpu/tril_kernel.cc
rename to paddle/phi/kernels/cpu/tril_triu_kernel.cc
index 82902a19772978199c6be8627e32716e82237753..1a5773d3dd2f9c55e5f53176a3b73eea531fc17d 100644
--- a/paddle/phi/kernels/cpu/tril_kernel.cc
+++ b/paddle/phi/kernels/cpu/tril_triu_kernel.cc
@@ -14,7 +14,29 @@
 
 #include "paddle/phi/backends/cpu/cpu_context.h"
 #include "paddle/phi/core/kernel_registry.h"
-#include "paddle/phi/kernels/impl/tril_kernel_impl.h"
+#include "paddle/phi/kernels/impl/tril_triu_kernel_impl.h"
+
+PD_REGISTER_KERNEL(tril_triu,
+                   CPU,
+                   ALL_LAYOUT,
+                   phi::TrilTriuKernel,
+                   bool,
+                   float,
+                   double,
+                   int,
+                   int64_t,
+                   phi::dtype::float16) {}
+
+PD_REGISTER_KERNEL(triu,
+                   CPU,
+                   ALL_LAYOUT,
+                   phi::TriuKernel,
+                   bool,
+                   float,
+                   double,
+                   int,
+                   int64_t,
+                   phi::dtype::float16) {}
 
 PD_REGISTER_KERNEL(tril,
                    CPU,
diff --git a/paddle/phi/kernels/gpu/layer_norm_grad_kernel.cu b/paddle/phi/kernels/gpu/layer_norm_grad_kernel.cu
index 961937441e1cf9154eef19fc014acc74466ceeca..0ec43eab3785c2be660e1b9627606753c28f2f28 100644
--- a/paddle/phi/kernels/gpu/layer_norm_grad_kernel.cu
+++ b/paddle/phi/kernels/gpu/layer_norm_grad_kernel.cu
@@ -31,7 +31,6 @@ void LayerNormGradKernel(const Context &dev_ctx,
                          const DenseTensor &out_grad,
                          float epsilon,
                          int begin_norm_axis,
-                         bool is_test,
                          DenseTensor *x_grad,
                          DenseTensor *scale_grad,
                          DenseTensor *bias_grad) {
diff --git a/paddle/phi/kernels/gpu/layer_norm_kernel.cu b/paddle/phi/kernels/gpu/layer_norm_kernel.cu
index f2ad08c68005882815bac9d8b7c5da42b7d9bd8d..1dd1070884732e54d1691a86c4431c5136499993 100644
--- a/paddle/phi/kernels/gpu/layer_norm_kernel.cu
+++ b/paddle/phi/kernels/gpu/layer_norm_kernel.cu
@@ -61,7 +61,6 @@ void LayerNormKernel(const Context &dev_ctx,
                      const paddle::optional<DenseTensor> &bias_opt,
                      float epsilon,
                      int begin_norm_axis,
-                     bool is_test,
                      DenseTensor *y,
                      DenseTensor *mean,
                      DenseTensor *var) {
diff --git a/paddle/phi/kernels/gpu/lstsq_kernel.cu b/paddle/phi/kernels/gpu/lstsq_kernel.cu
index 0e59dbe9df7fab44f40de590c72591b6320efd72..adb0ca09d89386196af304b8d3e48ca48d939f45 100644
--- a/paddle/phi/kernels/gpu/lstsq_kernel.cu
+++ b/paddle/phi/kernels/gpu/lstsq_kernel.cu
@@ -23,7 +23,7 @@
 #include "paddle/phi/kernels/funcs/slice.h"
 #include "paddle/phi/kernels/impl/lstsq_kernel_impl.h"
 #include "paddle/phi/kernels/impl/qr_kernel_impl.h"
-#include "paddle/phi/kernels/impl/tril_kernel_impl.h"
+#include "paddle/phi/kernels/impl/tril_triu_kernel_impl.h"
 #include "paddle/phi/kernels/lstsq_kernel.h"
 #include "paddle/phi/kernels/matmul_kernel.h"
 #include "paddle/phi/kernels/transpose_kernel.h"
@@ -110,7 +110,7 @@ void LstsqKernel(const Context& dev_ctx,
     DenseTensor* res_r = new DenseTensor();
     res_r->Resize(phi::make_ddim({batch_count, min_mn, min_mn}));
     dev_ctx.template Alloc<T>(res_r);
-    phi::TrilKernel<T>(dev_ctx, slice_r, 0, false, res_r);
+    phi::TrilTriuKernel<T>(dev_ctx, slice_r, 0, false, res_r);
 
     DenseTensor trans_y = phi::TransposeLast2Dim<T>(dev_ctx, tmp_y);
     DenseTensor slice_y =
@@ -135,7 +135,7 @@ void LstsqKernel(const Context& dev_ctx,
     DenseTensor* res_r = new DenseTensor();
     res_r->Resize(phi::make_ddim({batch_count, min_mn, min_mn}));
     dev_ctx.template Alloc<T>(res_r);
-    phi::TrilKernel<T>(dev_ctx, slice_r, 0, false, res_r);
+    phi::TrilTriuKernel<T>(dev_ctx, slice_r, 0, false, res_r);
 
     phi::TriangularSolveKernel<T, Context>(
         dev_ctx, *res_r, *new_y, true, true, false, solution);
diff --git a/paddle/phi/kernels/gpu/matrix_rank_kernel.cu b/paddle/phi/kernels/gpu/matrix_rank_kernel.cu
index 9727e2cc114c54ded660fd16893089c1c3750e78..73e703fcabb20147aa7dc7ab7d24f00f6992224c 100644
--- a/paddle/phi/kernels/gpu/matrix_rank_kernel.cu
+++ b/paddle/phi/kernels/gpu/matrix_rank_kernel.cu
@@ -27,8 +27,8 @@ template <typename T, typename Context>
 void MatrixRankKernel(const Context& dev_ctx,
                       const DenseTensor& x,
                       float tol,
-                      bool use_default_tol,
                       bool hermitian,
+                      bool use_default_tol,
                       DenseTensor* out) {
   DenseTensor atol_tensor;
   if (use_default_tol) {
diff --git a/paddle/phi/kernels/gpu/qr_kernel.cu b/paddle/phi/kernels/gpu/qr_kernel.cu
index 697cf952c1cecd1920ccc6dee9d7ca439d6019b9..99752ac486d6eb16649d025de0689d6bf4a13f86 100644
--- a/paddle/phi/kernels/gpu/qr_kernel.cu
+++ b/paddle/phi/kernels/gpu/qr_kernel.cu
@@ -31,7 +31,7 @@
 #include "paddle/phi/kernels/qr_kernel.h"
 #include "paddle/phi/kernels/slice_kernel.h"
 #include "paddle/phi/kernels/transpose_kernel.h"
-#include "paddle/phi/kernels/tril_kernel.h"
+#include "paddle/phi/kernels/tril_triu_kernel.h"
 
 namespace phi {
 
@@ -103,12 +103,12 @@ void QrKernel(const Context& ctx,
     auto trans_qr = TransposeLast2Dim<T, Context>(ctx, qr);
     auto sliced_qr = SliceKernel<T, Context>(
         ctx, trans_qr, {trans_qr.dims().size() - 2}, {0}, {min_mn}, {1}, {});
-    auto tmp_r = Tril<T, Context>(ctx, sliced_qr, 0, false);
+    auto tmp_r = TrilTriu<T, Context>(ctx, sliced_qr, 0, false);
     // Transpose 'tmp_r' to retore the original row-major order
     phi::Copy(ctx, tmp_r, r->place(), false, r);
   } else {
     auto trans_qr = TransposeLast2Dim<T, Context>(ctx, qr);
-    auto tmp_r = Tril<T, Context>(ctx, trans_qr, 0, false);
+    auto tmp_r = TrilTriu<T, Context>(ctx, trans_qr, 0, false);
     // Transpose 'tmp_r' to retore the original row-major order
     phi::Copy(ctx, tmp_r, r->place(), false, r);
   }
diff --git a/paddle/phi/kernels/gpu/tril_grad_kernel.cu b/paddle/phi/kernels/gpu/tril_triu_grad_kernel.cu
similarity index 60%
rename from paddle/phi/kernels/gpu/tril_grad_kernel.cu
rename to paddle/phi/kernels/gpu/tril_triu_grad_kernel.cu
index 5bda0e54b33a63e9de196288707a8773ef385d0f..5bd5b730acfeb09e864c183a20870c445e2bf144 100644
--- a/paddle/phi/kernels/gpu/tril_grad_kernel.cu
+++ b/paddle/phi/kernels/gpu/tril_triu_grad_kernel.cu
@@ -14,7 +14,7 @@
 
 #include "paddle/phi/backends/gpu/gpu_context.h"
 #include "paddle/phi/core/kernel_registry.h"
-#include "paddle/phi/kernels/impl/tril_grad_kernel_impl.h"
+#include "paddle/phi/kernels/impl/tril_triu_grad_kernel_impl.h"
 
 PD_REGISTER_KERNEL(tril_grad,
                    GPU,
@@ -26,3 +26,25 @@ PD_REGISTER_KERNEL(tril_grad,
                    int,
                    int64_t,
                    phi::dtype::float16) {}
+
+PD_REGISTER_KERNEL(triu_grad,
+                   GPU,
+                   ALL_LAYOUT,
+                   phi::TriuGradKernel,
+                   bool,
+                   float,
+                   double,
+                   int,
+                   int64_t,
+                   phi::dtype::float16) {}
+
+PD_REGISTER_KERNEL(tril_triu_grad,
+                   GPU,
+                   ALL_LAYOUT,
+                   phi::TrilTriuGradKernel,
+                   bool,
+                   float,
+                   double,
+                   int,
+                   int64_t,
+                   phi::dtype::float16) {}
diff --git a/paddle/phi/kernels/gpu/tril_kernel.cu b/paddle/phi/kernels/gpu/tril_triu_kernel.cu
similarity index 60%
rename from paddle/phi/kernels/gpu/tril_kernel.cu
rename to paddle/phi/kernels/gpu/tril_triu_kernel.cu
index c50b7c513fd0771face03125b8381223ba5065a5..6a7aa54f8e379cb424bfafd06d62984aae92245d 100644
--- a/paddle/phi/kernels/gpu/tril_kernel.cu
+++ b/paddle/phi/kernels/gpu/tril_triu_kernel.cu
@@ -14,7 +14,29 @@
 
 #include "paddle/phi/backends/gpu/gpu_context.h"
 #include "paddle/phi/core/kernel_registry.h"
-#include "paddle/phi/kernels/impl/tril_kernel_impl.h"
+#include "paddle/phi/kernels/impl/tril_triu_kernel_impl.h"
+
+PD_REGISTER_KERNEL(tril_triu,
+                   GPU,
+                   ALL_LAYOUT,
+                   phi::TrilTriuKernel,
+                   bool,
+                   float,
+                   double,
+                   int,
+                   int64_t,
+                   phi::dtype::float16) {}
+
+PD_REGISTER_KERNEL(triu,
+                   GPU,
+                   ALL_LAYOUT,
+                   phi::TriuKernel,
+                   bool,
+                   float,
+                   double,
+                   int,
+                   int64_t,
+                   phi::dtype::float16) {}
 
 PD_REGISTER_KERNEL(tril,
                    GPU,
diff --git a/paddle/phi/kernels/hsigmoid_loss_grad_kernel.h b/paddle/phi/kernels/hsigmoid_loss_grad_kernel.h
index e31d4291079904d4f4bf7285f33a9228d451acf3..c36b343017fd50ab4d4a8dfc5eda6962b9ee8391 100644
--- a/paddle/phi/kernels/hsigmoid_loss_grad_kernel.h
+++ b/paddle/phi/kernels/hsigmoid_loss_grad_kernel.h
@@ -30,10 +30,6 @@ void HSigmoidLossGradKernel(const Context& ctx,
                             const DenseTensor& out_grad,
                             int num_classes,
                             bool remote_prefetch,
-                            int trainer_id,
-                            const std::vector<int64_t>& height_sections,
-                            const std::vector<std::string>& epmap,
-                            const std::vector<std::string>& table_names,
                             bool is_sparse,
                             DenseTensor* x_grad,
                             DenseTensor* w_grad,
diff --git a/paddle/phi/kernels/hsigmoid_loss_kernel.h b/paddle/phi/kernels/hsigmoid_loss_kernel.h
index c8fb3ca77f3f91d7295411d4816fa5eda4af6d15..33a90c637e4e436ec0fedadda3372afa780cbf14 100644
--- a/paddle/phi/kernels/hsigmoid_loss_kernel.h
+++ b/paddle/phi/kernels/hsigmoid_loss_kernel.h
@@ -21,17 +21,13 @@ namespace phi {
 template <typename T, typename Context>
 void HSigmoidLossKernel(const Context& ctx,
                         const DenseTensor& x,
-                        const DenseTensor& w,
                         const DenseTensor& label,
+                        const DenseTensor& w,
+                        const paddle::optional<DenseTensor>& bias,
                         const paddle::optional<DenseTensor>& path,
                         const paddle::optional<DenseTensor>& code,
-                        const paddle::optional<DenseTensor>& bias,
                         int num_classes,
                         bool remote_prefetch,
-                        int trainer_id,
-                        const std::vector<int64_t>& height_sections,
-                        const std::vector<std::string>& epmap,
-                        const std::vector<std::string>& table_names,
                         bool is_sparse,
                         DenseTensor* out,
                         DenseTensor* pre_out,
diff --git a/paddle/phi/kernels/impl/qr_grad_kernel_impl.h b/paddle/phi/kernels/impl/qr_grad_kernel_impl.h
index 5ad59f757aa2278e51ea91d3dc59edcaa4ad678a..5c04d9bb90cfe560a749d4e751e075f37d89a5bf 100644
--- a/paddle/phi/kernels/impl/qr_grad_kernel_impl.h
+++ b/paddle/phi/kernels/impl/qr_grad_kernel_impl.h
@@ -29,7 +29,7 @@
 #include "paddle/phi/kernels/slice_kernel.h"
 #include "paddle/phi/kernels/transpose_kernel.h"
 #include "paddle/phi/kernels/triangular_solve_kernel.h"
-#include "paddle/phi/kernels/tril_kernel.h"
+#include "paddle/phi/kernels/tril_triu_kernel.h"
 
 namespace phi {
 
@@ -116,8 +116,8 @@ void QrGradKernel(const Context& ctx,
     DenseTensor M_tmp1 = Subtract<T, Context>(ctx, R_term, Q_term);
 
     // Compute M = (tril(M) + tril(M).mH()) * 0.5 Identity
-    DenseTensor M_tril_0 = Tril<T, Context>(ctx, M_tmp1, 0, true);
-    DenseTensor M_tril_1 = Tril<T, Context>(ctx, M_tmp1, -1, true);
+    DenseTensor M_tril_0 = TrilTriu<T, Context>(ctx, M_tmp1, 0, true);
+    DenseTensor M_tril_1 = TrilTriu<T, Context>(ctx, M_tmp1, -1, true);
     DenseTensor M = Add<T, Context>(
         ctx, M_tril_0, TransposeLast2Dim<T, Context>(ctx, M_tril_1));
 
diff --git a/paddle/phi/kernels/impl/tril_grad_kernel_impl.h b/paddle/phi/kernels/impl/tril_triu_grad_kernel_impl.h
similarity index 68%
rename from paddle/phi/kernels/impl/tril_grad_kernel_impl.h
rename to paddle/phi/kernels/impl/tril_triu_grad_kernel_impl.h
index 3f72d34a957bd5f4ddce01f77bf2e14e175deac0..173f09e35e2466b82679d0313b3faae2979997d5 100644
--- a/paddle/phi/kernels/impl/tril_grad_kernel_impl.h
+++ b/paddle/phi/kernels/impl/tril_triu_grad_kernel_impl.h
@@ -16,16 +16,16 @@
 
 #include "paddle/phi/kernels/funcs/for_range.h"
 #include "paddle/phi/kernels/funcs/tril_triu_compute.h"
-#include "paddle/phi/kernels/tril_grad_kernel.h"
+#include "paddle/phi/kernels/tril_triu_grad_kernel.h"
 
 namespace phi {
 
 template <typename T, typename Context>
-void TrilGradKernel(const Context& ctx,
-                    const DenseTensor& out_grad,
-                    int diagonal,
-                    bool lower,
-                    DenseTensor* x_grad) {
+void TrilTriuGradKernel(const Context& ctx,
+                        const DenseTensor& out_grad,
+                        int diagonal,
+                        bool lower,
+                        DenseTensor* x_grad) {
   const auto* dout_data = out_grad.data<T>();
   auto* dx_data = ctx.template Alloc<T>(x_grad);
 
@@ -40,4 +40,20 @@ void TrilGradKernel(const Context& ctx,
   for_range(tril_triu_grad_computer);
 }
 
+template <typename T, typename Context>
+void TrilGradKernel(const Context& ctx,
+                    const DenseTensor& out_grad,
+                    int diagonal,
+                    DenseTensor* x_grad) {
+  TrilTriuGradKernel<T, Context>(ctx, out_grad, diagonal, true, x_grad);
+}
+
+template <typename T, typename Context>
+void TriuGradKernel(const Context& ctx,
+                    const DenseTensor& out_grad,
+                    int diagonal,
+                    DenseTensor* x_grad) {
+  TrilTriuGradKernel<T, Context>(ctx, out_grad, diagonal, false, x_grad);
+}
+
 }  // namespace phi
diff --git a/paddle/phi/kernels/impl/tril_kernel_impl.h b/paddle/phi/kernels/impl/tril_triu_kernel_impl.h
similarity index 70%
rename from paddle/phi/kernels/impl/tril_kernel_impl.h
rename to paddle/phi/kernels/impl/tril_triu_kernel_impl.h
index 8e93e87fbc4d83d7ca1efa6d2c49aa362cda1b59..5820bbb3aaf08abc75426d36d07242778556ffd3 100644
--- a/paddle/phi/kernels/impl/tril_kernel_impl.h
+++ b/paddle/phi/kernels/impl/tril_triu_kernel_impl.h
@@ -16,16 +16,16 @@
 
 #include "paddle/phi/kernels/funcs/for_range.h"
 #include "paddle/phi/kernels/funcs/tril_triu_compute.h"
-#include "paddle/phi/kernels/tril_kernel.h"
+#include "paddle/phi/kernels/tril_triu_kernel.h"
 
 namespace phi {
 
 template <typename T, typename Context>
-void TrilKernel(const Context& ctx,
-                const DenseTensor& x,
-                int diagonal,
-                bool lower,
-                DenseTensor* out) {
+void TrilTriuKernel(const Context& ctx,
+                    const DenseTensor& x,
+                    int diagonal,
+                    bool lower,
+                    DenseTensor* out) {
   const auto* x_data = x.data<T>();
   auto* out_data = ctx.template Alloc<T>(out);
 
@@ -39,4 +39,20 @@ void TrilKernel(const Context& ctx,
   for_range(tril_triu_computer);
 }
 
+template <typename T, typename Context>
+void TrilKernel(const Context& ctx,
+                const DenseTensor& x,
+                int diagonal,
+                DenseTensor* out) {
+  TrilTriuKernel<T, Context>(ctx, x, diagonal, true, out);
+}
+
+template <typename T, typename Context>
+void TriuKernel(const Context& ctx,
+                const DenseTensor& x,
+                int diagonal,
+                DenseTensor* out) {
+  TrilTriuKernel<T, Context>(ctx, x, diagonal, false, out);
+}
+
 }  // namespace phi
diff --git a/paddle/phi/kernels/layer_norm_grad_kernel.h b/paddle/phi/kernels/layer_norm_grad_kernel.h
index 7d7cd13109be1ec26f33fd88970f8439b6d68389..81975760994decd1b0e3152cf77023a9a7fa7f14 100644
--- a/paddle/phi/kernels/layer_norm_grad_kernel.h
+++ b/paddle/phi/kernels/layer_norm_grad_kernel.h
@@ -28,7 +28,6 @@ void LayerNormGradKernel(const Context& ctx,
                          const DenseTensor& out_grad,
                          float epsilon,
                          int begin_norm_axis,
-                         bool is_test,
                          DenseTensor* x_grad,
                          DenseTensor* scale_grad,
                          DenseTensor* bias_grad);
diff --git a/paddle/phi/kernels/layer_norm_kernel.h b/paddle/phi/kernels/layer_norm_kernel.h
index 28ffdfd47719b3c1778b2912cacd31ef3eb05679..2fddcec2278c9a198181458afe7b63889633d935 100644
--- a/paddle/phi/kernels/layer_norm_kernel.h
+++ b/paddle/phi/kernels/layer_norm_kernel.h
@@ -26,7 +26,6 @@ void LayerNormKernel(const Context& ctx,
                      const paddle::optional<DenseTensor>& bias,
                      float epsilon,
                      int begin_norm_axis,
-                     bool is_test,
                      DenseTensor* out,
                      DenseTensor* mean,
                      DenseTensor* variance);
diff --git a/paddle/phi/kernels/matrix_rank_kernel.h b/paddle/phi/kernels/matrix_rank_kernel.h
index 6edea2723e589340f2c6dc3cfb0be6f895bf08bb..f0cb90097a3fc2b086c445f4e3c4a84505c5453c 100644
--- a/paddle/phi/kernels/matrix_rank_kernel.h
+++ b/paddle/phi/kernels/matrix_rank_kernel.h
@@ -22,8 +22,8 @@ template <typename T, typename Context>
 void MatrixRankKernel(const Context& dev_ctx,
                       const DenseTensor& x,
                       float tol,
-                      bool use_default_tol,
                       bool hermitian,
+                      bool use_default_tol,
                       DenseTensor* out);
 
 }  // namespace phi
diff --git a/paddle/phi/kernels/selected_rows/hsigmoid_loss_grad_kernel.cc b/paddle/phi/kernels/selected_rows/hsigmoid_loss_grad_kernel.cc
index 1fedcb14f5426b464f69c8301bc46c7eeb89a021..2512304944e85c76ba437a57a503add3a87aa656 100644
--- a/paddle/phi/kernels/selected_rows/hsigmoid_loss_grad_kernel.cc
+++ b/paddle/phi/kernels/selected_rows/hsigmoid_loss_grad_kernel.cc
@@ -47,10 +47,6 @@ void HSigmoidLossGradKernel(const Context& ctx,
                             const DenseTensor& out_grad,
                             int num_classes,
                             bool remote_prefetch,
-                            int trainer_id,
-                            const std::vector<int64_t>& height_sections,
-                            const std::vector<std::string>& epmap,
-                            const std::vector<std::string>& table_names,
                             bool is_sparse,
                             DenseTensor* x_grad,
                             SelectedRows* w_grad,
@@ -77,10 +73,6 @@ void HSigmoidLossGradKernel(const Context& ctx,
                                      out_grad,
                                      num_classes,
                                      remote_prefetch,
-                                     trainer_id,
-                                     height_sections,
-                                     epmap,
-                                     table_names,
                                      is_sparse,
                                      x_grad,
                                      w_grad_value,
diff --git a/paddle/phi/kernels/selected_rows/hsigmoid_loss_grad_kernel.h b/paddle/phi/kernels/selected_rows/hsigmoid_loss_grad_kernel.h
index fe4ffe24601ae4aca3074ab1be4a49d657966016..94ac63183fbfb831ec8841b02f4ab74dfeeeb188 100644
--- a/paddle/phi/kernels/selected_rows/hsigmoid_loss_grad_kernel.h
+++ b/paddle/phi/kernels/selected_rows/hsigmoid_loss_grad_kernel.h
@@ -32,10 +32,6 @@ void HSigmoidLossGradKernel(const Context& ctx,
                             const DenseTensor& out_grad,
                             int num_classes,
                             bool remote_prefetch,
-                            int trainer_id,
-                            const std::vector<int64_t>& height_sections,
-                            const std::vector<std::string>& epmap,
-                            const std::vector<std::string>& table_names,
                             bool is_sparse,
                             DenseTensor* x_grad,
                             SelectedRows* w_grad,
diff --git a/paddle/phi/kernels/tril_grad_kernel.h b/paddle/phi/kernels/tril_triu_grad_kernel.h
similarity index 66%
rename from paddle/phi/kernels/tril_grad_kernel.h
rename to paddle/phi/kernels/tril_triu_grad_kernel.h
index 7fc5e77363c62f76d9385cd95941c0287df15bd5..42ddc2aba9d8adbd43e734b8be221d516843f616 100644
--- a/paddle/phi/kernels/tril_grad_kernel.h
+++ b/paddle/phi/kernels/tril_triu_grad_kernel.h
@@ -18,11 +18,23 @@
 
 namespace phi {
 
+template <typename T, typename Context>
+void TrilTriuGradKernel(const Context& ctx,
+                        const DenseTensor& out_grad,
+                        int diagonal,
+                        bool lower,
+                        DenseTensor* x_grad);
+
 template <typename T, typename Context>
 void TrilGradKernel(const Context& ctx,
                     const DenseTensor& out_grad,
                     int diagonal,
-                    bool lower,
+                    DenseTensor* x_grad);
+
+template <typename T, typename Context>
+void TriuGradKernel(const Context& ctx,
+                    const DenseTensor& out_grad,
+                    int diagonal,
                     DenseTensor* x_grad);
 
 }  // namespace phi
diff --git a/paddle/phi/kernels/tril_kernel.h b/paddle/phi/kernels/tril_triu_kernel.h
similarity index 60%
rename from paddle/phi/kernels/tril_kernel.h
rename to paddle/phi/kernels/tril_triu_kernel.h
index 52154c2b2bcb56b1796fc6d54fa7c684855ea733..cbec3b6221da16ed5ae8205517d8023bf0648a47 100644
--- a/paddle/phi/kernels/tril_kernel.h
+++ b/paddle/phi/kernels/tril_triu_kernel.h
@@ -19,22 +19,34 @@
 
 namespace phi {
 
+template <typename T, typename Context>
+void TrilTriuKernel(const Context& ctx,
+                    const DenseTensor& x,
+                    int diagonal,
+                    bool lower,
+                    DenseTensor* out);
+
 template <typename T, typename Context>
 void TrilKernel(const Context& ctx,
                 const DenseTensor& x,
                 int diagonal,
-                bool lower,
                 DenseTensor* out);
 
 template <typename T, typename Context>
-DenseTensor Tril(const Context& ctx,
-                 const DenseTensor& x,
-                 int diagonal,
-                 bool lower) {
+void TriuKernel(const Context& ctx,
+                const DenseTensor& x,
+                int diagonal,
+                DenseTensor* out);
+
+template <typename T, typename Context>
+DenseTensor TrilTriu(const Context& ctx,
+                     const DenseTensor& x,
+                     int diagonal,
+                     bool lower) {
   DenseTensor dense_out;
   MetaTensor meta_out(&dense_out);
-  TrilInferMeta(x, diagonal, lower, &meta_out);
-  TrilKernel<T, Context>(ctx, x, diagonal, lower, &dense_out);
+  TrilTriuInferMeta(x, diagonal, lower, &meta_out);
+  TrilTriuKernel<T, Context>(ctx, x, diagonal, lower, &dense_out);
   return dense_out;
 }
 
diff --git a/paddle/phi/kernels/xpu/layer_norm_grad_kernel.cc b/paddle/phi/kernels/xpu/layer_norm_grad_kernel.cc
index d7d8e9058e8613b287ab8d0f1f18a2d2a75fd0d2..9bf2d779d0205af51c7ce268392b90b48f232186 100644
--- a/paddle/phi/kernels/xpu/layer_norm_grad_kernel.cc
+++ b/paddle/phi/kernels/xpu/layer_norm_grad_kernel.cc
@@ -29,7 +29,6 @@ void LayerNormGradKernel(const Context& ctx,
                          const DenseTensor& out_grad,
                          float epsilon,
                          int begin_norm_axis,
-                         bool is_test,
                          DenseTensor* x_grad,
                          DenseTensor* scale_grad,
                          DenseTensor* bias_grad) {
diff --git a/paddle/phi/kernels/xpu/layer_norm_kernel.cc b/paddle/phi/kernels/xpu/layer_norm_kernel.cc
index e1895bd0a745e01109bb3a64aab99f7d3a162781..8fc3edffbcd66224d7e7b649fb2d91ce9d63948c 100644
--- a/paddle/phi/kernels/xpu/layer_norm_kernel.cc
+++ b/paddle/phi/kernels/xpu/layer_norm_kernel.cc
@@ -26,7 +26,6 @@ void LayerNormKernel(const Context& ctx,
                      const paddle::optional<DenseTensor>& bias,
                      float epsilon,
                      int begin_norm_axis,
-                     bool is_test,
                      DenseTensor* out,
                      DenseTensor* mean,
                      DenseTensor* variance) {
diff --git a/paddle/phi/kernels/xpu/tril_grad_kernel.cc b/paddle/phi/kernels/xpu/tril_triu_grad_kernel.cc
similarity index 67%
rename from paddle/phi/kernels/xpu/tril_grad_kernel.cc
rename to paddle/phi/kernels/xpu/tril_triu_grad_kernel.cc
index af8dfdd8c0badc4a91a2e547d6571682b6cf0b01..bf6b083a431f7dfa9a31d9346939102318403534 100644
--- a/paddle/phi/kernels/xpu/tril_grad_kernel.cc
+++ b/paddle/phi/kernels/xpu/tril_triu_grad_kernel.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/phi/kernels/tril_grad_kernel.h"
+#include "paddle/phi/kernels/tril_triu_grad_kernel.h"
 
 #include "paddle/phi/backends/xpu/enforce_xpu.h"
 #include "paddle/phi/core/kernel_registry.h"
@@ -20,11 +20,11 @@
 namespace phi {
 
 template <typename T, typename Context>
-void TrilGradKernel(const Context& ctx,
-                    const DenseTensor& out_grad,
-                    int diagonal,
-                    bool lower,
-                    DenseTensor* x_grad) {
+void TrilTriuGradKernel(const Context& ctx,
+                        const DenseTensor& out_grad,
+                        int diagonal,
+                        bool lower,
+                        DenseTensor* x_grad) {
   using XPUType = typename XPUTypeTrait<T>::Type;
   ctx.template Alloc<T>(x_grad);
   auto dy_shape = vectorize<int>(out_grad.dims());
@@ -46,7 +46,27 @@ void TrilGradKernel(const Context& ctx,
   }
 }
 
+template <typename T, typename Context>
+void TrilGradKernel(const Context& ctx,
+                    const DenseTensor& out_grad,
+                    int diagonal,
+                    DenseTensor* x_grad) {
+  TrilTriuGradKernel<T, Context>(ctx, out_grad, diagonal, true, x_grad);
+}
+
+template <typename T, typename Context>
+void TriuGradKernel(const Context& ctx,
+                    const DenseTensor& out_grad,
+                    int diagonal,
+                    DenseTensor* x_grad) {
+  TrilTriuGradKernel<T, Context>(ctx, out_grad, diagonal, false, x_grad);
+}
+
 }  // namespace phi
 
 PD_REGISTER_KERNEL(
     tril_grad, XPU, ALL_LAYOUT, phi::TrilGradKernel, int, float) {}
+PD_REGISTER_KERNEL(
+    triu_grad, XPU, ALL_LAYOUT, phi::TriuGradKernel, int, float) {}
+PD_REGISTER_KERNEL(
+    tril_triu_grad, XPU, ALL_LAYOUT, phi::TrilTriuGradKernel, int, float) {}
diff --git a/paddle/phi/kernels/xpu/tril_kernel.cc b/paddle/phi/kernels/xpu/tril_triu_kernel.cc
similarity index 69%
rename from paddle/phi/kernels/xpu/tril_kernel.cc
rename to paddle/phi/kernels/xpu/tril_triu_kernel.cc
index 4b4cf579c26c602b9fbe51993431b9042b55ca02..98defd569167f5d3eeaac9d89dedcca9c00ebe9b 100644
--- a/paddle/phi/kernels/xpu/tril_kernel.cc
+++ b/paddle/phi/kernels/xpu/tril_triu_kernel.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/phi/kernels/tril_kernel.h"
+#include "paddle/phi/kernels/tril_triu_kernel.h"
 
 #include "paddle/phi/backends/xpu/enforce_xpu.h"
 #include "paddle/phi/core/kernel_registry.h"
@@ -20,11 +20,11 @@
 namespace phi {
 
 template <typename T, typename Context>
-void TrilKernel(const Context& ctx,
-                const DenseTensor& x,
-                int diagonal,
-                bool lower,
-                DenseTensor* out) {
+void TrilTriuKernel(const Context& ctx,
+                    const DenseTensor& x,
+                    int diagonal,
+                    bool lower,
+                    DenseTensor* out) {
   using XPUType = typename XPUTypeTrait<T>::Type;
   ctx.template Alloc<T>(out);
   auto xshape = vectorize<int>(x.dims());
@@ -46,6 +46,25 @@ void TrilKernel(const Context& ctx,
   }
 }
 
+template <typename T, typename Context>
+void TrilKernel(const Context& ctx,
+                const DenseTensor& x,
+                int diagonal,
+                DenseTensor* out) {
+  TrilTriuKernel<T, Context>(ctx, x, diagonal, true, out);
+}
+
+template <typename T, typename Context>
+void TriuKernel(const Context& ctx,
+                const DenseTensor& x,
+                int diagonal,
+                DenseTensor* out) {
+  TrilTriuKernel<T, Context>(ctx, x, diagonal, false, out);
+}
+
 }  // namespace phi
 
+PD_REGISTER_KERNEL(
+    tril_triu, XPU, ALL_LAYOUT, phi::TrilTriuKernel, int, float) {}
 PD_REGISTER_KERNEL(tril, XPU, ALL_LAYOUT, phi::TrilKernel, int, float) {}
+PD_REGISTER_KERNEL(triu, XPU, ALL_LAYOUT, phi::TriuKernel, int, float) {}
diff --git a/paddle/phi/ops/compat/hierarchical_sigmoid_sig.cc b/paddle/phi/ops/compat/hierarchical_sigmoid_sig.cc
index c4e04e5d40b02a2476af9ebbfefb5b699cb4ef57..a8db0b33242bd9c6279e7abc12f1d65dd8d09715 100644
--- a/paddle/phi/ops/compat/hierarchical_sigmoid_sig.cc
+++ b/paddle/phi/ops/compat/hierarchical_sigmoid_sig.cc
@@ -19,14 +19,8 @@ namespace phi {
 KernelSignature HierarchicalSigmoidOpArgumentMapping(
     const ArgumentMappingContext& ctx) {
   return KernelSignature("hsigmoid_loss",
-                         {"X", "W", "Label", "PathTable", "PathCode", "Bias"},
-                         {"num_classes",
-                          "remote_prefetch",
-                          "trainer_id",
-                          "height_sections",
-                          "epmap",
-                          "table_names",
-                          "is_sparse"},
+                         {"X", "Label", "W", "Bias", "PathTable", "PathCode"},
+                         {"num_classes", "remote_prefetch", "is_sparse"},
                          {"Out", "PreOut", "W_Out"});
 }
 
@@ -42,13 +36,7 @@ KernelSignature HierarchicalSigmoidGradOpArgumentMapping(
                             "Bias",
                             "PreOut",
                             "Out@GRAD"},
-                           {"num_classes",
-                            "remote_prefetch",
-                            "trainer_id",
-                            "height_sections",
-                            "epmap",
-                            "table_names",
-                            "is_sparse"},
+                           {"num_classes", "remote_prefetch", "is_sparse"},
                            {"X@GRAD", "W@GRAD", "Bias@GRAD"});
   } else if (ctx.IsSelectedRowsOutput("W@GRAD")) {
     return KernelSignature("hsigmoid_loss_grad_sr",
@@ -60,13 +48,7 @@ KernelSignature HierarchicalSigmoidGradOpArgumentMapping(
                             "Bias",
                             "PreOut",
                             "Out@GRAD"},
-                           {"num_classes",
-                            "remote_prefetch",
-                            "trainer_id",
-                            "height_sections",
-                            "epmap",
-                            "table_names",
-                            "is_sparse"},
+                           {"num_classes", "remote_prefetch", "is_sparse"},
                            {"X@GRAD", "W@GRAD", "Bias@GRAD"});
   } else {
     return KernelSignature("unregistered", {}, {}, {});
diff --git a/paddle/phi/ops/compat/layer_norm_sig.cc b/paddle/phi/ops/compat/layer_norm_sig.cc
index ab4f9ab8171575723bf6796d07cda2a6f9bf14bd..d2e75a700d2b80fdc0f858ddea6bcbdba062dd8d 100644
--- a/paddle/phi/ops/compat/layer_norm_sig.cc
+++ b/paddle/phi/ops/compat/layer_norm_sig.cc
@@ -19,7 +19,7 @@ namespace phi {
 KernelSignature LayerNormOpArgumentMapping(const ArgumentMappingContext& ctx) {
   return KernelSignature("layer_norm",
                          {"X", "Scale", "Bias"},
-                         {"epsilon", "begin_norm_axis", "is_test"},
+                         {"epsilon", "begin_norm_axis"},
                          {"Y", "Mean", "Variance"});
 }
 
@@ -27,7 +27,7 @@ KernelSignature LayerNormGradOpArgumentMapping(
     const ArgumentMappingContext& ctx) {
   return KernelSignature("layer_norm_grad",
                          {"X", "Scale", "Bias", "Mean", "Variance", "Y@GRAD"},
-                         {"epsilon", "begin_norm_axis", "is_test"},
+                         {"epsilon", "begin_norm_axis"},
                          {"X@GRAD", "Scale@GRAD", "Bias@GRAD"});
 }
 
diff --git a/paddle/phi/ops/compat/matrix_rank_sig.cc b/paddle/phi/ops/compat/matrix_rank_sig.cc
index bb884e9c3499b953db6594820923c7c069c8f046..3a9a040062703a5102e1451266e827227c318675 100644
--- a/paddle/phi/ops/compat/matrix_rank_sig.cc
+++ b/paddle/phi/ops/compat/matrix_rank_sig.cc
@@ -28,8 +28,8 @@ KernelSignature MatrixRankOpArgumentMapping(const ArgumentMappingContext& ctx) {
                            {"X"},
                            {
                                "tol",
-                               "use_default_tol",
                                "hermitian",
+                               "use_default_tol",
                            },
                            {"Out"});
   }
diff --git a/paddle/phi/ops/compat/tril_triu_sig.cc b/paddle/phi/ops/compat/tril_triu_sig.cc
index 3cf022c60e3da75a4bc328c5f79a4333db16e65a..3c5fa15b41cae0a1f590e29312aefe34d2427f60 100644
--- a/paddle/phi/ops/compat/tril_triu_sig.cc
+++ b/paddle/phi/ops/compat/tril_triu_sig.cc
@@ -17,19 +17,16 @@ limitations under the License. */
 namespace phi {
 
 KernelSignature TrilTriuOpArgumentMapping(const ArgumentMappingContext& ctx) {
-  return KernelSignature("tril", {"X"}, {"diagonal", "lower"}, {"Out"});
+  return KernelSignature("tril_triu", {"X"}, {"diagonal", "lower"}, {"Out"});
 }
 
 KernelSignature TrilTriuGradOpArgumentMapping(
     const ArgumentMappingContext& ctx) {
   return KernelSignature(
-      "tril_grad", {"Out@GRAD"}, {"diagonal", "lower"}, {"X@GRAD"});
+      "tril_triu_grad", {"Out@GRAD"}, {"diagonal", "lower"}, {"X@GRAD"});
 }
 
 }  // namespace phi
 
-PD_REGISTER_BASE_KERNEL_NAME(tril_triu, tril);
-PD_REGISTER_BASE_KERNEL_NAME(tril_triu_grad, tril_grad);
-
 PD_REGISTER_ARG_MAPPING_FN(tril_triu, phi::TrilTriuOpArgumentMapping);
 PD_REGISTER_ARG_MAPPING_FN(tril_triu_grad, phi::TrilTriuGradOpArgumentMapping);
diff --git a/python/paddle/fluid/dygraph/nn.py b/python/paddle/fluid/dygraph/nn.py
index 1c864a8cd90348cf8a6eac371f47c374fb5c6d1e..4c8b9d7f555f1bbe10cf4739b183c9f9deefaf2d 100644
--- a/python/paddle/fluid/dygraph/nn.py
+++ b/python/paddle/fluid/dygraph/nn.py
@@ -1782,7 +1782,6 @@ class LayerNorm(layers.Layer):
                     self.bias,
                     self._epsilon,
                     self._begin_norm_axis,
-                    False,
                 )
                 return dygraph_utils._append_activation_in_dygraph(
                     pre_act, act=self._act
diff --git a/python/paddle/fluid/tests/unittests/test_hsigmoid_op.py b/python/paddle/fluid/tests/unittests/test_hsigmoid_op.py
index 5ac218f9ebd7a2b95ac1472a4681f1ccb5902048..db3627d21ce75a1a8a8c83d32b1506904865abfa 100644
--- a/python/paddle/fluid/tests/unittests/test_hsigmoid_op.py
+++ b/python/paddle/fluid/tests/unittests/test_hsigmoid_op.py
@@ -170,18 +170,15 @@ def hsigmoidWithCustomTree(
 
 def python_api(
     input,
-    weight,
     label,
+    weight,
+    bias=None,
     path_table=None,
     path_code=None,
-    bias=None,
     num_classes=-1,
     is_sparse=False,
     remote_prefetch=False,
 ):
-    assert (
-        is_sparse == remote_prefetch
-    ), "is_sparse is equal to remote_prefetch in dygraph."
     return paddle.nn.functional.hsigmoid_loss(
         input,
         label,
diff --git a/python/paddle/fluid/tests/unittests/test_matrix_rank_op.py b/python/paddle/fluid/tests/unittests/test_matrix_rank_op.py
index 72c104ad85c288c1b66152a9b98a11296f8fabdc..671d0831a57bdb6e7f9c81490d956cdb26ee0759 100644
--- a/python/paddle/fluid/tests/unittests/test_matrix_rank_op.py
+++ b/python/paddle/fluid/tests/unittests/test_matrix_rank_op.py
@@ -26,7 +26,7 @@ SEED = 2049
 np.random.seed(SEED)
 
 
-def matrix_rank_wraper(x, tol=None, use_default_tol=True, hermitian=False):
+def matrix_rank_wraper(x, tol=None, hermitian=False, use_default_tol=True):
     return paddle.linalg.matrix_rank(x, tol, hermitian)
 
 
diff --git a/python/paddle/nn/functional/loss.py b/python/paddle/nn/functional/loss.py
index 6cf352086b415553bb2d15925998c4289992aeff..efe26e5a42ebf4b2166b24a51cdba688d0cee55b 100755
--- a/python/paddle/nn/functional/loss.py
+++ b/python/paddle/nn/functional/loss.py
@@ -1017,17 +1017,13 @@ def hsigmoid_loss(
     if in_dygraph_mode():
         out, _, _ = _C_ops.hsigmoid_loss(
             input,
-            weight,
             label,
+            weight,
+            bias,
             path_table,
             path_code,
-            bias,
             num_classes,
             is_sparse,
-            0,
-            [],
-            [],
-            [],
             is_sparse,
         )
         return out
diff --git a/python/paddle/nn/functional/norm.py b/python/paddle/nn/functional/norm.py
index cf487a23329fd6e892b454d3bc3885822ad8b0e3..c356b8c9940750e4dcd56ab4b040823992b796c9 100644
--- a/python/paddle/nn/functional/norm.py
+++ b/python/paddle/nn/functional/norm.py
@@ -385,7 +385,7 @@ def layer_norm(
             pre_act,
             _,
             _,
-        ) = _C_ops.layer_norm(x, weight, bias, epsilon, begin_norm_axis, False)
+        ) = _C_ops.layer_norm(x, weight, bias, epsilon, begin_norm_axis)
 
         return dygraph_utils._append_activation_in_dygraph(pre_act, act=None)
 
diff --git a/python/paddle/tensor/creation.py b/python/paddle/tensor/creation.py
index 774261237d228e254865101764f50df02a148594..9a907049f5400361ff6052be224b6aa4005fc059 100644
--- a/python/paddle/tensor/creation.py
+++ b/python/paddle/tensor/creation.py
@@ -1183,7 +1183,7 @@ def triu(x, diagonal=0, name=None):
 
     """
     if in_dygraph_mode():
-        return _C_ops.tril(x, diagonal, False)
+        return _C_ops.triu(x, diagonal, False)
 
     if _in_legacy_dygraph():
         op = getattr(_legacy_C_ops, 'tril_triu')
diff --git a/python/paddle/tensor/linalg.py b/python/paddle/tensor/linalg.py
index 41166b71a0cf67648953c02e6a3765d98f8590d0..1a3a5595928e30f72885b7bb61f720b69f1d1633 100644
--- a/python/paddle/tensor/linalg.py
+++ b/python/paddle/tensor/linalg.py
@@ -1601,7 +1601,7 @@ def matrix_rank(x, tol=None, hermitian=False, name=None):
         else:
             tol_attr = float(tol)
             use_default_tol = False
-        return _C_ops.matrix_rank(x, tol_attr, use_default_tol, hermitian)
+        return _C_ops.matrix_rank(x, tol_attr, hermitian, use_default_tol)
 
     if _in_legacy_dygraph():
         if tol is None: