update

paddle/fluid/operators/lu_op.h

@@ -41,9 +41,12 @@ void SetValueCompute(const framework::ExecutionContext& ctx,
   auto dtype = framework::TransToProtoVarType(in->dtype());
 
   auto in_dims = in->dims();
-  CheckAndUpdateSliceAttrs<int64_t>(in_dims, axes, starts, ends, &steps);
-  auto slice_dims = GetSliceDims(in_dims, axes, *starts, *ends, &steps);
-  auto decrease_slice_dims = GetDecreasedDims(slice_dims, decrease_axes);
+  phi::funcs::CheckAndUpdateSliceAttrs<int64_t>(in_dims, axes, starts, ends,
+                                                &steps);
+  auto slice_dims =
+      phi::funcs::GetSliceDims(in_dims, axes, *starts, *ends, &steps);
+  auto decrease_slice_dims =
+      phi::funcs::GetDecreasedDims(slice_dims, decrease_axes);
 
   auto slice_dims_for_assign = decrease_slice_dims;
   if (!none_axes.empty()) {
@@ -281,10 +284,10 @@ void SliceCompute(const framework::ExecutionContext& ctx,
     }
   }
 
-  CheckAndUpdateSliceAttrs(in_dims, axes, &starts, &ends);
-  slice_dims =
-      GetSliceDims<int64_t>(in_dims, axes, starts, ends, nullptr, nullptr);
-  out_dims = GetDecreasedDims(slice_dims, decrease_axis);
+  phi::funcs::CheckAndUpdateSliceAttrs(in_dims, axes, &starts, &ends);
+  slice_dims = phi::funcs::GetSliceDims<int64_t>(in_dims, axes, starts, ends,
+                                                 nullptr, nullptr);
+  out_dims = phi::funcs::GetDecreasedDims(slice_dims, decrease_axis);
 
   // 2.2 Get output
   auto offsets = Eigen::DSizes<Eigen::DenseIndex, D>();

paddle/fluid/operators/set_value_op.h

@@ -25,10 +25,10 @@
 #include "paddle/fluid/operators/assign_value_op.h"
 #include "paddle/fluid/operators/eigen/eigen_function.h"
 #include "paddle/fluid/operators/elementwise/elementwise_op_function.h"
-#include "paddle/fluid/operators/slice_utils.h"
 #include "paddle/fluid/operators/strided_slice_op.h"
 #include "paddle/fluid/operators/utils.h"
 #include "paddle/fluid/platform/enforce.h"
+#include "paddle/phi/kernels/funcs/slice_utils.h"
 
 namespace paddle {
 namespace operators {
@@ -188,9 +188,11 @@ class SetValueKernel : public framework::OpKernel<T> {
     }
 
     auto in_dims = in->dims();
-    CheckAndUpdateSliceAttrs(in_dims, axes, &starts, &ends, &steps);
-    auto slice_dims = GetSliceDims(in_dims, axes, starts, ends, &steps);
-    auto decrease_slice_dims = GetDecreasedDims(slice_dims, decrease_axes);
+    phi::funcs::CheckAndUpdateSliceAttrs(in_dims, axes, &starts, &ends, &steps);
+    auto slice_dims =
+        phi::funcs::GetSliceDims(in_dims, axes, starts, ends, &steps);
+    auto decrease_slice_dims =
+        phi::funcs::GetDecreasedDims(slice_dims, decrease_axes);
 
     auto slice_dims_for_assign = decrease_slice_dims;
     if (!none_axes.empty()) {

paddle/fluid/operators/slice_op.cc

@@ -17,6 +17,7 @@ limitations under the License. */
 #include <memory>
 #include <string>
 #include <vector>
+#include "paddle/phi/kernels/funcs/slice_utils.h"
 
 namespace paddle {
 namespace operators {
@@ -101,15 +102,17 @@ class SliceOp : public framework::OperatorWithKernel {
               "The size of ends must be equal to the size of axes."));
     }
 
-    CheckAndUpdateSliceAttrs<int>(in_dims, axes, &starts, &ends, nullptr,
-                                  &infer_flags);
+    phi::funcs::CheckAndUpdateSliceAttrs<int>(in_dims, axes, &starts, &ends,
+                                              nullptr, &infer_flags);
 
-    auto slice_dims =
-        GetSliceDims<int>(in_dims, axes, starts, ends, nullptr, &infer_flags);
+    auto slice_dims = phi::funcs::GetSliceDims<int>(in_dims, axes, starts, ends,
+                                                    nullptr, &infer_flags);
     if (ctx->IsRuntime()) {
-      out_dims = GetDecreasedDims<int>(slice_dims, decrease_axis, &infer_flags);
+      out_dims = phi::funcs::GetDecreasedDims<int>(slice_dims, decrease_axis,
+                                                   &infer_flags);
     } else {
-      out_dims = GetDecreasedDims<int>(slice_dims, decrease_axis, nullptr);
+      out_dims =
+          phi::funcs::GetDecreasedDims<int>(slice_dims, decrease_axis, nullptr);
     }
 
     ctx->SetOutputDim("Out", out_dims);

paddle/fluid/operators/slice_op.h

@@ -18,7 +18,6 @@ limitations under the License. */
 #include <vector>
 #include "paddle/fluid/framework/op_registry.h"
 #include "paddle/fluid/operators/eigen/eigen_function.h"
-#include "paddle/fluid/operators/slice_utils.h"
 #include "paddle/fluid/operators/utils.h"
 #include "paddle/phi/kernels/funcs/math_function.h"
 

paddle/phi/kernels/cpu/slice_grad_kernel.cc

@@ -29,5 +29,4 @@ PD_REGISTER_KERNEL(slice_grad,
                    double,
                    phi::dtype::complex<float>,
                    phi::dtype::complex<double>,
-                   phi::dtype::bfloat16,
-                   phi::dtype::float16) {}
+                   phi::dtype::bfloat16) {}

paddle/phi/kernels/funcs/slice_utils.h

@@ -19,6 +19,8 @@ limitations under the License. */
 
 namespace phi {
 
+namespace funcs {
+
 template <typename T = int64_t>
 inline void CheckAndUpdateSliceAttrs(const DDim in_dims,
                                      const std::vector<T>& axes,
@@ -161,4 +163,5 @@ inline DDim GetDecreasedDims(const DDim slice_dims,
   return decreased_dims;
 }
 
+}  // namespace funcs
 }  // namespace phi

paddle/phi/kernels/gpu/slice_grad_kernel.cu

-// 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/kernels/impl/slice_grad_kernel_impl.h"
-#include "paddle/phi/kernels/slice_grad_kernel.h"
-
-#include "paddle/phi/backends/gpu/gpu_context.h"
-#include "paddle/phi/core/kernel_registry.h"
-
-PD_REGISTER_KERNEL(slice_grad,
-                   GPU,
-                   ALL_LAYOUT,
-                   phi::SliceGradRawKernel,
-                   bool,
-                   int,
-                   int64_t,
-                   float,
-                   double,
-                   phi::dtype::complex<float>,
-                   phi::dtype::complex<double>,
-                   phi::dtype::bfloat16,
-                   phi::dtype::float16) {}

paddle/phi/kernels/gpu/slice_kernel.cu.cc

@@ -29,4 +29,5 @@ PD_REGISTER_KERNEL(slice,
                    double,
                    phi::dtype::complex<float>,
                    phi::dtype::complex<double>,
-                   phi::dtype::bfloat16) {}
+                   phi::dtype::bfloat16,
+                   phi::dtype::float16) {}

paddle/phi/kernels/impl/slice_grad_kernel_impl.h

@@ -66,136 +66,143 @@ void EigenPaddingCompute(
     // if dimension less than 3, cannot reduce dimension
     LaunchEigenPadding<T, Context, D>(
         context, d_input, in_dims, d_out, out_dims, paddings);
-  }
-  // } else {  // else we can reduce dimension
-  //   // count not-zero padding number, and record the dimension
-  //   int need_pad_num = 0, pad_dim = -1;
-  //   for (size_t i = 0; i < D; i++) {
-  //     if (paddings[i].first != 0 || paddings[i].second != 0) {
-  //       need_pad_num++;
-  //       pad_dim = i;
-  //     }
-  //   }
+  } else {  // else we can reduce dimension
+    // count not-zero padding number, and record the dimension
+    int need_pad_num = 0, pad_dim = -1;
+    for (size_t i = 0; i < D; i++) {
+      if (paddings[i].first != 0 || paddings[i].second != 0) {
+        need_pad_num++;
+        pad_dim = i;
+      }
+    }
 
-  //   if (need_pad_num == 1) {
-  //     // only need padding one dimension, we can reduce dimension.
-  //     // only the padding dimension is available for us.
-  //     // How to reduce dimension(5 to 3 for example):
-  //     // before(D=5):
-  //     // in_dims:        [x1,  x2,  x3,  x4,  x5]
-  //     // padding.first:  [0,   0,   a,   0,  0]
-  //     // padding.second: [0,   0,   b,   0,  0]
-  //     //                     | |
-  //     //                     V V
-  //     // after(D=3):
-  //     // reshaped_in_dims:        [x1*x2,  x3,  x4*x5]
-  //     // reshaped_padding.first:  [0,      a,     0]
-  //     // reshaped_padding.second: [0,      b,     0]
+    if (need_pad_num == 1) {
+      // only need padding one dimension, we can reduce dimension.
+      // only the padding dimension is available for us.
+      // How to reduce dimension(5 to 3 for example):
+      // before(D=5):
+      // in_dims:        [x1,  x2,  x3,  x4,  x5]
+      // padding.first:  [0,   0,   a,   0,  0]
+      // padding.second: [0,   0,   b,   0,  0]
+      //                     | |
+      //                     V V
+      // after(D=3):
+      // reshaped_in_dims:        [x1*x2,  x3,  x4*x5]
+      // reshaped_padding.first:  [0,      a,     0]
+      // reshaped_padding.second: [0,      b,     0]
 
-  //     if (pad_dim == D - 1) {
-  //       // only last dimension need padding,
-  //       // reshape the dimension of tensor in 2: [preceding, padding]
-  //       std::vector<int64_t> in_tore_shape(2, 1), out_tore_shape(2, 1);
-  //       Eigen::array<std::pair<int64_t, int64_t>, 2> reshaped_padding;
+      if (pad_dim == D - 1) {
+        // only last dimension need padding,
+        // reshape the dimension of tensor in 2: [preceding, padding]
+        std::vector<int64_t> in_tore_shape(2, 1), out_tore_shape(2, 1);
+        Eigen::array<std::pair<int64_t, int64_t>, 2> reshaped_padding;
 
-  //       // first dimension is the accumulate of preceding dimension
-  //       for (int i = 0; i < pad_dim; i++) {
-  //         in_tore_shape[0] *= in_dims[i];
-  //         out_tore_shape[0] *= out_dims[i];
-  //       }
-  //       // second dimension is the padding dimension
-  //       in_tore_shape[1] = in_dims[pad_dim];
-  //       out_tore_shape[1] = out_dims[pad_dim];
+        // first dimension is the accumulate of preceding dimension
+        for (int i = 0; i < pad_dim; i++) {
+          in_tore_shape[0] *= in_dims[i];
+          out_tore_shape[0] *= out_dims[i];
+        }
+        // second dimension is the padding dimension
+        in_tore_shape[1] = in_dims[pad_dim];
+        out_tore_shape[1] = out_dims[pad_dim];
 
-  //       // convert array from std::vector to DDim
-  //       DDim reshaped_in_dims = make_ddim(in_tore_shape);
-  //       DDim reshaped_out_dims = make_ddim(out_tore_shape);
+        // convert array from std::vector to DDim
+        DDim reshaped_in_dims = make_ddim(in_tore_shape);
+        DDim reshaped_out_dims = make_ddim(out_tore_shape);
 
-  //       // after reshape: the first dimension do not need padding,
-  //       // set padding[0] zero
-  //       reshaped_padding[0].first = reshaped_padding[0].second = 0;
-  //       // the second dimension is the previous padding dimension
-  //       reshaped_padding[1].first = paddings[pad_dim].first;
-  //       reshaped_padding[1].second = paddings[pad_dim].second;
+        // after reshape: the first dimension do not need padding,
+        // set padding[0] zero
+        reshaped_padding[0].first = reshaped_padding[0].second = 0;
+        // the second dimension is the previous padding dimension
+        reshaped_padding[1].first = paddings[pad_dim].first;
+        reshaped_padding[1].second = paddings[pad_dim].second;
 
-  //       LaunchEigenPadding<T, Context, D>(context, d_input, reshaped_in_dims,
-  //       d_out,
-  //                          reshaped_out_dims, reshaped_padding);
-  //     } else if (pad_dim == 0) {
-  //       // only first dimension need padding,
-  //       // reshape the dimension of tensor in 2: [padding, succeeding]
-  //       // similar to (D - 1)
-  //       std::vector<int64_t> in_tore_shape(2, 1), out_tore_shape(2, 1);
-  //       Eigen::array<std::pair<int64_t, int64_t>, 2> reshaped_padding;
+        LaunchEigenPadding<T, Context>(context,
+                                       d_input,
+                                       reshaped_in_dims,
+                                       d_out,
+                                       reshaped_out_dims,
+                                       reshaped_padding);
+      } else if (pad_dim == 0) {
+        // only first dimension need padding,
+        // reshape the dimension of tensor in 2: [padding, succeeding]
+        // similar to (D - 1)
+        std::vector<int64_t> in_tore_shape(2, 1), out_tore_shape(2, 1);
+        Eigen::array<std::pair<int64_t, int64_t>, 2> reshaped_padding;
 
-  //       // first dimension is the padding dimension
-  //       in_tore_shape[0] = in_dims[pad_dim];
-  //       out_tore_shape[0] = out_dims[pad_dim];
-  //       // sencond dimension is the accumulate of succeeding dimension
-  //       for (size_t i = pad_dim + 1; i < D; i++) {
-  //         in_tore_shape[1] *= in_dims[i];
-  //         out_tore_shape[1] *= out_dims[i];
-  //       }
+        // first dimension is the padding dimension
+        in_tore_shape[0] = in_dims[pad_dim];
+        out_tore_shape[0] = out_dims[pad_dim];
+        // sencond dimension is the accumulate of succeeding dimension
+        for (size_t i = pad_dim + 1; i < D; i++) {
+          in_tore_shape[1] *= in_dims[i];
+          out_tore_shape[1] *= out_dims[i];
+        }
 
-  //       // convert array from std::vector to DDim
-  //       DDim reshaped_in_dims = make_ddim(in_tore_shape);
-  //       DDim reshaped_out_dims = make_ddim(out_tore_shape);
+        // convert array from std::vector to DDim
+        DDim reshaped_in_dims = make_ddim(in_tore_shape);
+        DDim reshaped_out_dims = make_ddim(out_tore_shape);
 
-  //       // after reshape:
-  //       // the first dimension is the previous padding dimension
-  //       reshaped_padding[0].first = paddings[pad_dim].first;
-  //       reshaped_padding[0].second = paddings[pad_dim].second;
-  //       // the second dimension do not need padding, set padding[1] zero
-  //       reshaped_padding[1].first = reshaped_padding[1].second = 0;
+        // after reshape:
+        // the first dimension is the previous padding dimension
+        reshaped_padding[0].first = paddings[pad_dim].first;
+        reshaped_padding[0].second = paddings[pad_dim].second;
+        // the second dimension do not need padding, set padding[1] zero
+        reshaped_padding[1].first = reshaped_padding[1].second = 0;
 
-  //       LaunchEigenPadding<T, Context, D>(context, d_input, reshaped_in_dims,
-  //       d_out,
-  //                          reshaped_out_dims, reshaped_padding);
-  //     } else {
-  //       // other dimension need padding
-  //       // reshape the dimension of tensor in 3:
-  //       // [preceding, padding, succeeding]
-  //       std::vector<int64_t> in_tore_shape(3, 1), out_tore_shape(3, 1);
-  //       Eigen::array<std::pair<int64_t, int64_t>, 3> reshaped_padding;
+        LaunchEigenPadding<T, Context>(context,
+                                       d_input,
+                                       reshaped_in_dims,
+                                       d_out,
+                                       reshaped_out_dims,
+                                       reshaped_padding);
+      } else {
+        // other dimension need padding
+        // reshape the dimension of tensor in 3:
+        // [preceding, padding, succeeding]
+        std::vector<int64_t> in_tore_shape(3, 1), out_tore_shape(3, 1);
+        Eigen::array<std::pair<int64_t, int64_t>, 3> reshaped_padding;
 
-  //       // first dimension is the accumulate of preceding dimension
-  //       for (int i = 0; i < pad_dim; i++) {
-  //         in_tore_shape[0] *= in_dims[i];
-  //         out_tore_shape[0] *= out_dims[i];
-  //       }
-  //       // second dimension is the padding dimension
-  //       in_tore_shape[1] = in_dims[pad_dim];
-  //       out_tore_shape[1] = out_dims[pad_dim];
-  //       // third dimension is the accumulate of succeeding dimension
-  //       for (size_t i = pad_dim + 1; i < D; i++) {
-  //         in_tore_shape[2] *= in_dims[i];
-  //         out_tore_shape[2] *= out_dims[i];
-  //       }
+        // first dimension is the accumulate of preceding dimension
+        for (int i = 0; i < pad_dim; i++) {
+          in_tore_shape[0] *= in_dims[i];
+          out_tore_shape[0] *= out_dims[i];
+        }
+        // second dimension is the padding dimension
+        in_tore_shape[1] = in_dims[pad_dim];
+        out_tore_shape[1] = out_dims[pad_dim];
+        // third dimension is the accumulate of succeeding dimension
+        for (size_t i = pad_dim + 1; i < D; i++) {
+          in_tore_shape[2] *= in_dims[i];
+          out_tore_shape[2] *= out_dims[i];
+        }
 
-  //       // convert array from std::vector to DDim
-  //       DDim reshaped_in_dims = make_ddim(in_tore_shape);
-  //       DDim reshaped_out_dims = make_ddim(out_tore_shape);
+        // convert array from std::vector to DDim
+        DDim reshaped_in_dims = make_ddim(in_tore_shape);
+        DDim reshaped_out_dims = make_ddim(out_tore_shape);
 
-  //       // after reshape:
-  //       // the first dimension do not need padding, set padding[0] zero
-  //       reshaped_padding[0].first = reshaped_padding[2].second = 0;
-  //       // the second dimension is the previous padding dimension
-  //       reshaped_padding[1].first = paddings[pad_dim].first;
-  //       reshaped_padding[1].second = paddings[pad_dim].second;
-  //       // the third dimension do not need padding, set padding[2] zero
-  //       reshaped_padding[2].first = reshaped_padding[2].second = 0;
+        // after reshape:
+        // the first dimension do not need padding, set padding[0] zero
+        reshaped_padding[0].first = reshaped_padding[2].second = 0;
+        // the second dimension is the previous padding dimension
+        reshaped_padding[1].first = paddings[pad_dim].first;
+        reshaped_padding[1].second = paddings[pad_dim].second;
+        // the third dimension do not need padding, set padding[2] zero
+        reshaped_padding[2].first = reshaped_padding[2].second = 0;
 
-  //       LaunchEigenPadding<T, Context, D>(context, d_input, reshaped_in_dims,
-  //       d_out,
-  //                          reshaped_out_dims, reshaped_padding);
-  //     }
-  //   } else {
-  //     // need padding at many dimension, cannot reduce dimension
-  //     LaunchEigenPadding<T, Context, D>(context, d_input, in_dims, d_out,
-  //     out_dims,
-  //                        paddings);
-  //   }
-  // }
+        LaunchEigenPadding<T, Context>(context,
+                                       d_input,
+                                       reshaped_in_dims,
+                                       d_out,
+                                       reshaped_out_dims,
+                                       reshaped_padding);
+      }
+    } else {
+      // need padding at many dimension, cannot reduce dimension
+      LaunchEigenPadding<T, Context>(
+          context, d_input, in_dims, d_out, out_dims, paddings);
+    }
+  }
 }
 
 template <typename T, typename Context, size_t D>

paddle/phi/kernels/impl/slice_kernel_impl.h

@@ -60,10 +60,10 @@ void SliceCompute(const Context& ctx,
     }
   }
 
-  CheckAndUpdateSliceAttrs<int64_t>(in_dims, axes, &starts, &ends);
-  slice_dims =
-      GetSliceDims<int64_t>(in_dims, axes, starts, ends, nullptr, nullptr);
-  out_dims = GetDecreasedDims<int64_t>(slice_dims, decrease_axis);
+  funcs::CheckAndUpdateSliceAttrs<int64_t>(in_dims, axes, &starts, &ends);
+  slice_dims = funcs::GetSliceDims<int64_t>(
+      in_dims, axes, starts, ends, nullptr, nullptr);
+  out_dims = funcs::GetDecreasedDims<int64_t>(slice_dims, decrease_axis);
 
   // 2.2 Get output
   auto offsets = Eigen::DSizes<Eigen::DenseIndex, D>();