Remove oneDNN-specific attributes from matmul

paddle/fluid/framework/ir/fuse_gemm_epilogue_pass.cc

@@ -81,8 +81,7 @@ ir::Graph *FuseGemmEpiloguePass::FuseLinearFwd(ir::Graph *graph,
     // currently. The conditions below are used to verify wether matmul_v2
     // is created by paddle.nn.Linear
     auto matmul_op_desc = matmul_op->Op();
-    if (!IsGemmFromLinear_(matmul_x_shape, matmul_w_shape, matmul_op_desc))
-      return;
+    if (!IsGemmFromLinear_(matmul_x_shape, matmul_w_shape)) return;
 
     bool trans_x, trans_y;
     GetTransposeAttrsFromOp(*matmul_op_desc, &trans_x, &trans_y);
@@ -165,8 +164,7 @@ ir::Graph *FuseGemmEpiloguePass::FuseLinearActFwd(
     // currently. The conditions below are used to verify wether matmul_v2
     // is created by paddle.nn.Linear
     auto matmul_op_desc = matmul_op->Op();
-    if (!IsGemmFromLinear_(matmul_x_shape, matmul_w_shape, matmul_op_desc))
-      return;
+    if (!IsGemmFromLinear_(matmul_x_shape, matmul_w_shape)) return;
 
     auto activation = act_op->Op()->Type();
 
@@ -291,9 +289,7 @@ ir::Graph *FuseGemmEpiloguePass::FuseLinearBwd(ir::Graph *graph,
     // currently. The conditions below are used to verify wether matmul_v2
     // is created by paddle.nn.Linear
     auto matmul_grad_op_desc = matmul_grad_op->Op();
-    if (!IsGemmFromLinear_(
-            matmul_grad_x_shape, matmul_grad_w_shape, matmul_grad_op_desc))
-      return;
+    if (!IsGemmFromLinear_(matmul_grad_x_shape, matmul_grad_w_shape)) return;
 
     bool trans_x, trans_y;
     GetTransposeAttrsFromOp(*matmul_grad_op_desc, &trans_x, &trans_y);
@@ -430,9 +426,7 @@ ir::Graph *FuseGemmEpiloguePass::FuseLinearActBwd(
     // currently. The conditions below are used to verify wether matmul_v2
     // is created by paddle.nn.Linear
     auto matmul_grad_op_desc = matmul_grad_op->Op();
-    if (!IsGemmFromLinear_(
-            matmul_grad_x_shape, matmul_grad_w_shape, matmul_grad_op_desc))
-      return;
+    if (!IsGemmFromLinear_(matmul_grad_x_shape, matmul_grad_w_shape)) return;
 
     auto activation_grad = act_grad_op->Op()->Type();
 
@@ -509,22 +503,8 @@ ir::Graph *FuseGemmEpiloguePass::FuseLinearActBwd(
 
 bool FuseGemmEpiloguePass::IsGemmFromLinear_(
     const std::vector<int64_t> &x_shape,
-    const std::vector<int64_t> &w_shape,
-    OpDesc *matmul_v2_op) const {
-  if (w_shape.size() != 2 || x_shape.size() < 2) return false;
-  for (auto attr_name : {"fused_reshape_Out",
-                         "fused_reshape_X",
-                         "fused_reshape_Y",
-                         "fused_transpose_Out",
-                         "fused_transpose_X",
-                         "fused_transpose_Y"}) {
-    if (matmul_v2_op->HasAttr(attr_name)) {
-      std::vector<int> tmp_vec =
-          PADDLE_GET_CONST(std::vector<int>, matmul_v2_op->GetAttr(attr_name));
-      if (tmp_vec.size() > 0) return false;
-    }
-  }
-  return true;
+    const std::vector<int64_t> &w_shape) const {
+  return (w_shape.size() == 2 && x_shape.size() >= 2);
 }
 
 }  // namespace ir

paddle/fluid/framework/ir/fuse_gemm_epilogue_pass.h

@@ -90,8 +90,7 @@ class FuseGemmEpiloguePass : public FusePassBase {
 
  private:
   bool IsGemmFromLinear_(const std::vector<int64_t> &x_shape,
-                         const std::vector<int64_t> &w_shape,
-                         OpDesc *matmul_v2_op) const;
+                         const std::vector<int64_t> &w_shape) const;
   const std::string GetReserveSpaceCacheKey(const std::string var_name,
                                             int block_id) const {
     return std::to_string(block_id) + var_name;

paddle/fluid/operators/compat/matmul.pbtxt

@@ -75,28 +75,4 @@ extra {
     name: "force_fp32_output"
     type: BOOLEAN
   }
-  attrs {
-    name: "fused_reshape_Out"
-    type: INTS
-  }
-  attrs {
-    name: "fused_reshape_X"
-    type: INTS
-  }
-  attrs {
-    name: "fused_reshape_Y"
-    type: INTS
-  }
-  attrs {
-    name: "fused_transpose_Out"
-    type: INTS
-  }
-  attrs {
-    name: "fused_transpose_X"
-    type: INTS
-  }
-  attrs {
-    name: "fused_transpose_Y"
-    type: INTS
-  }
 }

paddle/fluid/operators/feed_forward_test.cu

@@ -1,4 +1,4 @@
-/* Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+/* Copyright (c) 2023 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.
@@ -167,12 +167,6 @@ void GetLinearOpGrad(const std::vector<T> &x_vec,
       dout_ptr, dout_vec.data(), size_z * sizeof(T), cudaMemcpyHostToDevice);
 
   bool use_mkldnn = false;
-  std::vector<int> fused_reshape_X = {};
-  std::vector<int> fused_reshape_Y = {};
-  std::vector<int> fused_reshape_Out = {};
-  std::vector<int> fused_transpose_X = {};
-  std::vector<int> fused_transpose_Y = {};
-  std::vector<int> fused_transpose_Out = {};
   bool use_quantizer = false, force_fp32_output = false;
   std::string mkldnn_data_type = "float32";
   float Scale_x = 1.0, Scale_y = 1.0, Scale_out = 1.0;
@@ -182,12 +176,6 @@ void GetLinearOpGrad(const std::vector<T> &x_vec,
   attrs.insert({"transpose_Y", transpose_b});
   attrs.insert({"alpha", alpha});
   attrs.insert({"use_mkldnn", use_mkldnn});
-  attrs.insert({"fused_reshape_X", fused_reshape_X});
-  attrs.insert({"fused_reshape_Y", fused_reshape_Y});
-  attrs.insert({"fused_reshape_Out", fused_reshape_Out});
-  attrs.insert({"fused_transpose_X", fused_transpose_X});
-  attrs.insert({"fused_transpose_Y", fused_transpose_Y});
-  attrs.insert({"fused_transpose_Out", fused_transpose_Out});
   attrs.insert({"use_quantizer", use_quantizer});
   attrs.insert({"mkldnn_data_type", mkldnn_data_type});
   attrs.insert({"Scale_x", Scale_x});

paddle/fluid/operators/matmul_op.cc

@@ -1,4 +1,4 @@
-/* Copyright (c) 2017 PaddlePaddle Authors. All Rights Reserved.
+/* Copyright (c) 2023 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
@@ -16,9 +16,6 @@ limitations under the License. */
 #include "paddle/fluid/framework/op_registry.h"
 #include "paddle/fluid/framework/op_version_registry.h"
 #include "paddle/phi/kernels/funcs/blas/blas.h"
-#ifdef PADDLE_WITH_MKLDNN
-#include "paddle/fluid/platform/mkldnn_helper.h"
-#endif
 
 namespace paddle {
 namespace operators {
@@ -302,15 +299,15 @@ class MatMulGradKernel : public framework::OpKernel<T> {
     bool transpose_y = context.Attr<bool>("transpose_Y");
 
     ReshapeXYOutIntoMatrixSequence(&x, &y, &dout, transpose_x, transpose_y);
-    framework::DDim dx_dims;
+    phi::DDim dx_dims;
     if (dx) {
       dx_dims = dx->dims();
       if (dx_dims != x.dims()) {
         dx->Resize(x.dims());
       }
     }
 
-    framework::DDim dy_dims;
+    phi::DDim dy_dims;
     if (dy) {
       dy_dims = dy->dims();
       if (dy_dims != y.dims()) {
@@ -345,23 +342,15 @@ class MatMulGradKernel : public framework::OpKernel<T> {
   }
 };
 
-framework::DDim GetDimForInput(const framework::InferShapeContext &ctx,
-                               std::string input_name) {
-  auto shape = ctx.Attrs().Get<std::vector<int>>("fused_reshape_" + input_name);
-  auto axis =
-      ctx.Attrs().Get<std::vector<int>>("fused_transpose_" + input_name);
+phi::DDim GetDimForInput(const framework::InferShapeContext &ctx,
+                         std::string input_name) {
   auto dim = ctx.GetInputDim(input_name);
-
   PADDLE_ENFORCE_GT(dim.size(),
                     0,
-                    platform::errors::InvalidArgument(
+                    phi::errors::InvalidArgument(
                         "The Input(%s) has not been initialized properly. The "
                         "shape of Input(%s) = [%s].",
                         dim));
-
-  if (!shape.empty() && !axis.empty()) {
-    dim = dim.reshape(shape).transpose(axis);
-  }
   return dim;
 }
 
@@ -447,23 +436,23 @@ class MatMulDoubleGradKernel : public framework::OpKernel<T> {
 
     ReshapeXYOutIntoMatrixSequence(&x, &y, &dout, transpose_x, transpose_y);
 
-    framework::DDim dx_dims;
+    phi::DDim dx_dims;
     if (dx) {
       dx_dims = dx->dims();
       if (dx_dims != x.dims()) {
         dx->Resize(x.dims());
       }
     }
 
-    framework::DDim dy_dims;
+    phi::DDim dy_dims;
     if (dy) {
       dy_dims = dy->dims();
       if (dy_dims != y.dims()) {
         dy->Resize(y.dims());
       }
     }
 
-    framework::DDim ddout_dims;
+    phi::DDim ddout_dims;
     if (ddout) {
       ddout_dims = ddout->dims();
       if (ddout_dims != dout.dims()) {
@@ -615,7 +604,7 @@ class MatMulOp : public framework::OperatorWithKernel {
           mat_dim_x.batch_size_ == mat_dim_y.batch_size_ ||
               mat_dim_x.batch_size_ == 0 || mat_dim_y.batch_size_ == 0,
           true,
-          platform::errors::InvalidArgument(
+          phi::errors::InvalidArgument(
               "The batch size of the two matrices should be equal, or "
               "at least one is zero.\n"
               "But received X's shape: %s, Y's shape: %s.",
@@ -631,7 +620,7 @@ class MatMulOp : public framework::OperatorWithKernel {
       PADDLE_ENFORCE_LE(
           head_number,
           mat_dim_x.width_,
-          platform::errors::InvalidArgument(
+          phi::errors::InvalidArgument(
               "Unsatisfied mkl acceleration library requirements: "
               "The number of heads "
               "(%d) must be equal to X's width. But received X's shape: %s.",
@@ -645,7 +634,7 @@ class MatMulOp : public framework::OperatorWithKernel {
 #else
     PADDLE_ENFORCE_EQ(mat_dim_x.width_,
                       mat_dim_y.height_,
-                      platform::errors::InvalidArgument(
+                      phi::errors::InvalidArgument(
                           "Input X's width should be equal to the Y's height, "
                           "but received X's shape: [%s], "
                           "Y's shape: [%s].",
@@ -679,16 +668,8 @@ class MatMulOp : public framework::OperatorWithKernel {
       dim_out = {1};
     }
 
-    framework::DDim ddim_out = phi::make_ddim(dim_out);
-
-#ifdef PADDLE_WITH_MKLDNN
-    auto shape = context->Attrs().Get<std::vector<int>>("fused_reshape_Out");
-    auto axis = context->Attrs().Get<std::vector<int>>("fused_transpose_Out");
+    phi::DDim ddim_out = phi::make_ddim(dim_out);
 
-    if (!shape.empty() && !axis.empty()) {
-      ddim_out = ddim_out.transpose(axis).reshape(shape);
-    }
-#endif
     context->SetOutputDim("Out", ddim_out);
     context->ShareLoD("X", "Out");
   }
@@ -747,34 +728,6 @@ class MatMulOpMaker : public framework::OpProtoAndCheckerMaker {
         "(bool, default false) Indicates if MKL-DNN kernel will be used")
         .SetDefault(false)
         .AsExtra();
-    AddAttr<std::vector<int>>("fused_reshape_X",
-                              R"DOC(Shape of fused reshape of `X` input.)DOC")
-        .SetDefault({})
-        .AsExtra();
-    AddAttr<std::vector<int>>("fused_reshape_Y",
-                              R"DOC(Shape of fused reshape of `Y` input.)DOC")
-        .SetDefault({})
-        .AsExtra();
-    AddAttr<std::vector<int>>("fused_transpose_X",
-                              R"DOC(Axis of fused transpose of `X` input.)DOC")
-        .SetDefault({})
-        .AsExtra();
-    AddAttr<std::vector<int>>("fused_transpose_Y",
-                              R"DOC(Axis of fused transpose of `Y` input.)DOC")
-        .SetDefault({})
-        .AsExtra();
-    AddAttr<std::vector<int>>(
-        "fused_reshape_Out",
-        R"DOC(When MKLDNN MatMul_transpose_reshape fuse activated, "
-              "it's a shape attribute of fused reshape for `Out` output.)DOC")
-        .SetDefault({})
-        .AsExtra();
-    AddAttr<std::vector<int>>(
-        "fused_transpose_Out",
-        R"DOC(When MKLDNN MatMul_transpose_reshape fuse activated, "
-              "it's a axis attribute of fused transpose for `Out` output.)DOC")
-        .SetDefault({})
-        .AsExtra();
     AddAttr<bool>(
         "use_quantizer",
         "(bool, default false) "