rename_bilinear_tensor_product (#52375)

* rename_bilinear_tensor_product

* fix

paddle/fluid/operators/bilinear_tensor_product_op.cc

@@ -92,7 +92,7 @@ namespace ops = paddle::operators;
 
 DECLARE_INFER_SHAPE_FUNCTOR(bilinear_tensor_product,
                             BilinearTensorProductInferShapeFunctor,
-                            PD_INFER_META(phi::BilinearTensorProductInferMeta));
+                            PD_INFER_META(phi::BilinearInferMeta));
 DECLARE_INFER_SHAPE_FUNCTOR(
     bilinear_tensor_product_grad,
     BilinearTensorProductGradInferShapeFunctor,

paddle/phi/api/yaml/legacy_backward.yaml

@@ -152,7 +152,7 @@
   infer_meta :
     func : BilinearTensorProductGradInferMeta
   kernel :
-    func : bilinear_tensor_product_grad
+    func : bilinear_grad
 
 - backward_op : cast_grad
   forward : cast (Tensor x, DataType dtype) -> Tensor(out)

paddle/phi/api/yaml/legacy_ops.yaml

@@ -227,9 +227,9 @@
   args : (Tensor x, Tensor y, Tensor weight, Tensor bias)
   output : Tensor
   infer_meta :
-    func : BilinearTensorProductInferMeta
+    func : BilinearInferMeta
   kernel :
-    func : bilinear_tensor_product
+    func : bilinear
   optional : bias
   backward : bilinear_tensor_product_grad
 

paddle/phi/infermeta/multiary.cc

@@ -695,7 +695,7 @@ void BatchNormInferInferMeta(const MetaTensor& x,
                      config);
 }
 
-void BilinearTensorProductInferMeta(const MetaTensor& x,
+void BilinearInferMeta(const MetaTensor& x,
                        const MetaTensor& y,
                        const MetaTensor& weight,
                        const MetaTensor& bias,

paddle/phi/infermeta/multiary.h

@@ -198,7 +198,7 @@ void BatchNormInferInferMeta(const MetaTensor& x,
                              MetaTensor* variance_out,
                              MetaConfig config = MetaConfig());
 
-void BilinearTensorProductInferMeta(const MetaTensor& x,
+void BilinearInferMeta(const MetaTensor& x,
                        const MetaTensor& y,
                        const MetaTensor& weight,
                        const MetaTensor& bias,

paddle/phi/kernels/bilinear_tensor_product_grad_kernel.h → paddle/phi/kernels/bilinear_grad_kernel.h

@@ -19,7 +19,7 @@
 namespace phi {
 
 template <typename T, typename Context>
-void BilinearTensorProductGradKernel(const Context& dev_ctx,
+void BilinearGradKernel(const Context& dev_ctx,
                         const DenseTensor& x,
                         const DenseTensor& y,
                         const DenseTensor& weight,

paddle/phi/kernels/bilinear_tensor_product_kernel.h → paddle/phi/kernels/bilinear_kernel.h

@@ -20,7 +20,7 @@
 namespace phi {
 
 template <typename T, typename Context>
-void BilinearTensorProductKernel(const Context& dev_ctx,
+void BilinearKernel(const Context& dev_ctx,
                     const DenseTensor& x,
                     const DenseTensor& y,
                     const DenseTensor& weight,

paddle/phi/kernels/gpu/bilinear_tensor_product_kernel.cu → paddle/phi/kernels/cpu/bilinear_grad_kernel.cc

@@ -12,14 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/phi/kernels/bilinear_tensor_product_kernel.h"
+#include "paddle/phi/kernels/bilinear_grad_kernel.h"
 
 #include "paddle/phi/core/kernel_registry.h"
-#include "paddle/phi/kernels/impl/bilinear_tensor_product_kernel_impl.h"
+#include "paddle/phi/kernels/impl/bilinear_grad_kernel_impl.h"
 
-PD_REGISTER_KERNEL(bilinear_tensor_product,
-                   GPU,
-                   ALL_LAYOUT,
-                   phi::BilinearTensorProductKernel,
-                   float,
-                   double) {}
+PD_REGISTER_KERNEL(
+    bilinear_grad, CPU, ALL_LAYOUT, phi::BilinearGradKernel, float, double) {}

paddle/phi/kernels/cpu/bilinear_tensor_product_kernel.cc → paddle/phi/kernels/cpu/bilinear_kernel.cc

@@ -12,14 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/phi/kernels/bilinear_tensor_product_kernel.h"
+#include "paddle/phi/kernels/bilinear_kernel.h"
 
 #include "paddle/phi/core/kernel_registry.h"
-#include "paddle/phi/kernels/impl/bilinear_tensor_product_kernel_impl.h"
+#include "paddle/phi/kernels/impl/bilinear_kernel_impl.h"
 
-PD_REGISTER_KERNEL(bilinear_tensor_product,
-                   CPU,
-                   ALL_LAYOUT,
-                   phi::BilinearTensorProductKernel,
-                   float,
-                   double) {}
+PD_REGISTER_KERNEL(
+    bilinear, CPU, ALL_LAYOUT, phi::BilinearKernel, float, double) {}

paddle/phi/kernels/gpu/bilinear_tensor_product_grad_kernel.cu → paddle/phi/kernels/gpu/bilinear_grad_kernel.cu

@@ -12,14 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/phi/kernels/bilinear_tensor_product_grad_kernel.h"
+#include "paddle/phi/kernels/bilinear_grad_kernel.h"
 
 #include "paddle/phi/core/kernel_registry.h"
-#include "paddle/phi/kernels/impl/bilinear_tensor_product_grad_kernel_impl.h"
+#include "paddle/phi/kernels/impl/bilinear_grad_kernel_impl.h"
 
-PD_REGISTER_KERNEL(bilinear_tensor_product_grad,
-                   GPU,
-                   ALL_LAYOUT,
-                   phi::BilinearTensorProductGradKernel,
-                   float,
-                   double) {}
+PD_REGISTER_KERNEL(
+    bilinear_grad, GPU, ALL_LAYOUT, phi::BilinearGradKernel, float, double) {}

paddle/phi/kernels/cpu/bilinear_tensor_product_grad_kernel.cc → paddle/phi/kernels/gpu/bilinear_kernel.cu

@@ -12,14 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/phi/kernels/bilinear_tensor_product_grad_kernel.h"
+#include "paddle/phi/kernels/bilinear_kernel.h"
 
 #include "paddle/phi/core/kernel_registry.h"
-#include "paddle/phi/kernels/impl/bilinear_tensor_product_grad_kernel_impl.h"
+#include "paddle/phi/kernels/impl/bilinear_kernel_impl.h"
 
-PD_REGISTER_KERNEL(bilinear_tensor_product_grad,
-                   CPU,
-                   ALL_LAYOUT,
-                   phi::BilinearTensorProductGradKernel,
-                   float,
-                   double) {}
+PD_REGISTER_KERNEL(
+    bilinear, GPU, ALL_LAYOUT, phi::BilinearKernel, float, double) {}

paddle/phi/kernels/impl/bilinear_tensor_product_grad_kernel_impl.h → paddle/phi/kernels/impl/bilinear_grad_kernel_impl.h

@@ -21,7 +21,7 @@
 namespace phi {
 
 template <typename T, typename Context>
-void BilinearTensorProductGradKernel(const Context& ctx,
+void BilinearGradKernel(const Context& ctx,
                         const DenseTensor& x,
                         const DenseTensor& y,
                         const DenseTensor& weight,

paddle/phi/kernels/impl/bilinear_tensor_product_kernel_impl.h → paddle/phi/kernels/impl/bilinear_kernel_impl.h

@@ -22,7 +22,7 @@
 namespace phi {
 
 template <typename T, typename Context>
-void BilinearTensorProductKernel(const Context& ctx,
+void BilinearKernel(const Context& ctx,
                     const DenseTensor& x,
                     const DenseTensor& y,
                     const DenseTensor& weight,

paddle/phi/ops/compat/bilinear_tensor_product_sig.cc

@@ -18,13 +18,12 @@ namespace phi {
 
 KernelSignature BilinearTensorProductOpArgumentMapping(
     const ArgumentMappingContext& ctx) {
-  return KernelSignature(
-      "bilinear_tensor_product", {"X", "Y", "Weight", "Bias"}, {}, {"Out"});
+  return KernelSignature("bilinear", {"X", "Y", "Weight", "Bias"}, {}, {"Out"});
 }
 
 KernelSignature BilinearTensorProductGradOpArgumentMapping(
     const ArgumentMappingContext& ctx) {
-  return KernelSignature("bilinear_tensor_product_grad",
+  return KernelSignature("bilinear_grad",
                          {"X", "Y", "Weight", "Out@GRAD"},
                          {},
                          {"X@GRAD", "Y@GRAD", "Weight@GRAD", "Bias@GRAD"});